From e09c440989fc9363110fc9415dd8c91d82d513da Mon Sep 17 00:00:00 2001
From: Ross Patterson <me@rpatterson.net>
Date: Mon, 5 Aug 2019 07:40:09 -0700
Subject: [PATCH 01/37] Add support for extracting ffmpeg build data, such as
 hwaccels

This can be useful for projects that want to auto-detect optimal options for
invoking ffmpeg.
---
 ffmpeg/_build.py | 306 +++++++++++++++++++++++++++++++++++++++++++++++
 setup.py         |   4 +
 2 files changed, 310 insertions(+)
 create mode 100644 ffmpeg/_build.py

diff --git a/ffmpeg/_build.py b/ffmpeg/_build.py
new file mode 100644
index 00000000..f6a59de4
--- /dev/null
+++ b/ffmpeg/_build.py
@@ -0,0 +1,306 @@
+"""
+Extract details about the ffmpeg build.
+"""
+
+import sys
+import re
+import subprocess
+import json
+import logging
+import argparse
+
+logger = logging.getLogger(__name__)
+
+parser = argparse.ArgumentParser(description=__doc__)
+parser.add_argument(
+    '--ffmpeg', type=argparse.FileType('r'),
+    help='The path to the ffmpeg execuatble')
+
+
+VERSION_RE = re.compile(r' version (?P<version>[^ ]+) ')
+
+MUXER_RE = re.compile(
+    r'^ (?P<demuxing>[D ])(?P<muxing>[E ]) '
+    r'(?P<name>[^ ]+) +(?P<description>.+)$',
+    re.M)
+MUXER_FLAGS = dict(demuxing='D', muxing='E')
+
+CODEC_RE = re.compile(
+    r'^ (?P<decoding>[D.])(?P<encoding>[E.])'
+    r'(?P<stream>[VAS.])(?P<intra_frame>[I.])'
+    r'(?P<lossy>[L.])(?P<lossless>[S.]) '
+    r'(?P<name>[^ ]+) +(?P<description>.+)$',
+    re.M)
+CODEC_FLAGS = dict(
+    decoding='D', encoding='E',
+    stream=dict(video='V', audio='A', subtitle='S'),
+    intra_frame='I', lossy='L', lossless='S')
+CODEC_DESCRIPTION_RE = re.compile(
+    r'^(?P<description>.+?) \((de|en)coders: [^)]+ \)')
+CODEC_CODERS_RE = re.compile(
+    r' \((?P<type>(de|en)coders): (?P<coders>[^)]+) \)')
+
+FILTER_RE = re.compile(
+    r'^ (?P<timeline>[T.])(?P<slice>[S.])(?P<command>[C.]) '
+    r'(?P<name>[^ ]+) +(?P<io>[^ ]+) +(?P<description>.+)$',
+    re.M)
+FILTER_FLAGS = dict(timeline='T', slice='S', command='C')
+
+PIX_FMT_RE = re.compile(
+    r'^(?P<input>[I.])(?P<output>[O.])(?P<accelerated>[H.])'
+    r'(?P<palleted>[P.])(?P<bitstream>[B.]) '
+    r'(?P<name>[^ ]+) +(?P<components>[0-9]+) +(?P<bits>[0-9]+)$',
+    re.M)
+PIX_FMT_FLAGS = dict(
+    input='I', output='O', accelerated='H', palleted='P', bitstream='B')
+PIX_FMT_INT_FIELDS = {'components', 'bits'}
+
+
+def _run(args):
+    """
+    Run the command and return stdout but only print stderr on failure.
+    """
+    process = subprocess.Popen(
+        args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    stdout, stderr = process.communicate()
+    if process.returncode != 0:
+        logger.error(stderr.decode())
+        raise subprocess.CalledProcessError(
+            process.returncode, process.args, output=stdout, stderr=stderr)
+    return stdout.decode()
+
+def _get_line_fields(
+        stdout, header_lines, line_re, flags={}, int_fields=set()):
+    """
+    Extract field values from a line using the regular expression.
+    """
+    non_fields = set(flags).union({'name'})
+    lines = stdout.split('\n', header_lines)[header_lines]
+    data = {}
+    for match in line_re.finditer(lines):
+        groupdict = match.groupdict()
+
+        data[match.group('name')] = fields = {
+            key: key in int_fields and int(value) or value
+            for key, value in groupdict.items()
+            if key not in non_fields}
+
+        if flags:
+            fields['flags'] = {}
+            for key, flag in flags.items():
+                if isinstance(flag, dict):
+                    fields['flags'][key] = groupdict[key]
+                    for sub_key, sub_flag in flag.items():
+                        fields['flags'][sub_key] = groupdict[key] == sub_flag
+                else:
+                    fields['flags'][key] = groupdict[key] == flag
+
+    return data
+
+
+def get_version(cmd='ffmpeg'):
+    """
+    Extract the version of the ffmpeg build.
+    """
+    stdout = _run([cmd, '-version'])
+    match = VERSION_RE.search(stdout.split('\n')[0])
+    return match.group('version')
+
+
+def get_formats(cmd='ffmpeg'):
+    """
+    Extract the formats of the ffmpeg build.
+    """
+    stdout = _run([cmd, '-formats'])
+    return _get_line_fields(stdout, 4, MUXER_RE, MUXER_FLAGS)
+
+
+def get_demuxers(cmd='ffmpeg'):
+    """
+    Extract the demuxers of the ffmpeg build.
+    """
+    stdout = _run([cmd, '-demuxers'])
+    return _get_line_fields(stdout, 4, MUXER_RE, MUXER_FLAGS)
+
+
+def get_muxers(cmd='ffmpeg'):
+    """
+    Extract the muxers of the ffmpeg build.
+    """
+    stdout = _run([cmd, '-muxers'])
+    return _get_line_fields(stdout, 4, MUXER_RE, MUXER_FLAGS)
+
+
+def get_codecs(cmd='ffmpeg'):
+    """
+    Extract the codecs of the ffmpeg build.
+    """
+    stdout = _run([cmd, '-codecs'])
+    codecs = _get_line_fields(stdout, 10, CODEC_RE, CODEC_FLAGS)
+    for codec in codecs.values():
+        for coders_match in CODEC_CODERS_RE.finditer(codec['description']):
+            codec[coders_match.group(1)] = coders_match.group(3).split()
+        description_match = CODEC_DESCRIPTION_RE.search(codec['description'])
+        if description_match is not None:
+            codec['description'] = description_match.group('description')
+    return codecs
+
+
+def get_bsfs(cmd='ffmpeg'):
+    """
+    Extract the bsfs of the ffmpeg build.
+    """
+    stdout = _run([cmd, '-bsfs'])
+    return stdout.split('\n')[1:-2]
+
+
+def get_protocols(cmd='ffmpeg'):
+    """
+    Extract the protocols of the ffmpeg build.
+    """
+    stdout = [
+        line.strip() for line in
+        _run([cmd, '-protocols']).split('\n')]
+    input_idx = stdout.index('Input:')
+    output_idx = stdout.index('Output:')
+    return dict(
+        input=stdout[input_idx + 1:output_idx],
+        output=stdout[output_idx + 1:-1])
+
+
+def get_filters(cmd='ffmpeg'):
+    """
+    Extract the filters of the ffmpeg build.
+    """
+    stdout = _run([cmd, '-filters'])
+    return _get_line_fields(stdout, 8, FILTER_RE, FILTER_FLAGS)
+
+
+def get_pix_fmts(cmd='ffmpeg'):
+    """
+    Extract the pix_fmts of the ffmpeg build.
+    """
+    stdout = _run([cmd, '-pix_fmts'])
+    return _get_line_fields(
+        stdout, 8, PIX_FMT_RE, PIX_FMT_FLAGS, PIX_FMT_INT_FIELDS)
+
+
+def get_sample_fmts(cmd='ffmpeg'):
+    """
+    Extract the sample_fmts of the ffmpeg build.
+    """
+    stdout = _run([cmd, '-sample_fmts'])
+    fmts = {}
+    for line in stdout.split('\n')[1:-1]:
+        name, depth = line.split()
+        fmts[name] = int(depth)
+    return fmts
+
+
+def get_layouts(cmd='ffmpeg'):
+    """
+    Extract the layouts of the ffmpeg build.
+    """
+    stdout = _run([cmd, '-layouts']).split('\n')
+    channels_idx = stdout.index('Individual channels:')
+    layouts_idx = stdout.index('Standard channel layouts:')
+    data = {}
+
+    data['channels'] = channels = {}
+    for line in stdout[channels_idx + 2:layouts_idx - 1]:
+        name, description = line.split(None, 1)
+        channels[name] = description
+
+    data['layouts'] = layouts = {}
+    for line in stdout[layouts_idx + 2:-1]:
+        name, decomposition = line.split(None, 1)
+        layouts[name] = decomposition.split('+')
+
+    return data
+
+
+def get_colors(cmd='ffmpeg'):
+    """
+    Extract the colors of the ffmpeg build.
+    """
+    stdout = _run([cmd, '-colors'])
+    return dict(line.split() for line in stdout.split('\n')[1:-1])
+
+
+def get_devices(cmd='ffmpeg'):
+    """
+    Extract the devices of the ffmpeg build.
+    """
+    stdout = _run([cmd, '-devices'])
+    return _get_line_fields(stdout, 4, MUXER_RE, MUXER_FLAGS)
+
+
+def get_hw_devices(cmd='ffmpeg'):
+    """
+    Extract the hardware devices of the ffmpeg build.
+    """
+    stdout = _run([cmd, '-init_hw_device', 'list'])
+    return stdout.split('\n')[1:-2]
+
+
+def get_hwaccels(cmd='ffmpeg'):
+    """
+    Extract the hwaccels of the ffmpeg build.
+    """
+    stdout = _run([cmd, '-hwaccels'])
+    return stdout.split('\n')[1:-2]
+
+
+def get_build_data(cmd='ffmpeg'):
+    """
+    Extract details about the ffmpeg build.
+    """
+    return dict(
+        version=get_version(cmd='ffmpeg'),
+        formats=get_formats(cmd='ffmpeg'),
+        demuxers=get_demuxers(cmd='ffmpeg'),
+        muxers=get_muxers(cmd='ffmpeg'),
+        codecs=get_codecs(cmd='ffmpeg'),
+        bsfs=get_bsfs(cmd='ffmpeg'),
+        protocols=get_protocols(cmd='ffmpeg'),
+        filters=get_filters(cmd='ffmpeg'),
+        pix_fmts=get_pix_fmts(cmd='ffmpeg'),
+        sample_fmts=get_sample_fmts(cmd='ffmpeg'),
+        layouts=get_layouts(cmd='ffmpeg'),
+        colors=get_colors(cmd='ffmpeg'),
+        devices=get_devices(cmd='ffmpeg'),
+        hw_devices=get_hw_devices(cmd='ffmpeg'),
+        hwaccels=get_hwaccels(cmd='ffmpeg'))
+
+__all__ = [
+    'get_build_data',
+    'get_version',
+    'get_version',
+    'get_formats',
+    'get_demuxers',
+    'get_muxers',
+    'get_codecs',
+    'get_bsfs',
+    'get_protocols',
+    'get_filters',
+    'get_pix_fmts',
+    'get_sample_fmts',
+    'get_layouts',
+    'get_colors',
+    'get_devices',
+    'get_hw_devices',
+    'get_hwaccels',
+]
+
+
+def main(args=None):
+    """
+    Dump all ffmpeg build data to json.
+    """
+    args = parser.parse_args(args)
+    data = get_build_data(args.ffmpeg)
+    json.dump(data, sys.stdout, indent=2)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/setup.py b/setup.py
index 0282c67e..da567b8b 100644
--- a/setup.py
+++ b/setup.py
@@ -95,4 +95,8 @@
         'Programming Language :: Python :: 3.5',
         'Programming Language :: Python :: 3.6',
     ],
+    entry_points = {
+        'console_scripts': [
+            'ffmpeg-build-json=ffmpeg._build:main'],
+    },
 )

From 34adcb88dd30332d707756ebb3bbfd29c5bb2a1d Mon Sep 17 00:00:00 2001
From: Ross Patterson <me@rpatterson.net>
Date: Mon, 5 Aug 2019 13:29:18 -0700
Subject: [PATCH 02/37] Build data: Add basic test for coverage

---
 ffmpeg/__init__.py          |  3 +++
 ffmpeg/tests/test_ffmpeg.py | 22 ++++++++++++++++++++++
 2 files changed, 25 insertions(+)

diff --git a/ffmpeg/__init__.py b/ffmpeg/__init__.py
index a88d344d..a3100aa1 100644
--- a/ffmpeg/__init__.py
+++ b/ffmpeg/__init__.py
@@ -1,11 +1,13 @@
 from __future__ import unicode_literals
 from . import nodes
+from . import _build
 from . import _ffmpeg
 from . import _filters
 from . import _probe
 from . import _run
 from . import _view
 from .nodes import *
+from ._build import *
 from ._ffmpeg import *
 from ._filters import *
 from ._probe import *
@@ -14,6 +16,7 @@
 
 __all__ = (
     nodes.__all__
+    + _build.__all__
     + _ffmpeg.__all__
     + _probe.__all__
     + _run.__all__
diff --git a/ffmpeg/tests/test_ffmpeg.py b/ffmpeg/tests/test_ffmpeg.py
index 279a323e..086a980d 100644
--- a/ffmpeg/tests/test_ffmpeg.py
+++ b/ffmpeg/tests/test_ffmpeg.py
@@ -718,6 +718,28 @@ def test__probe__extra_args():
     assert set(data.keys()) == {'format', 'streams', 'frames'}
 
 
+def test__build_data():
+    data = ffmpeg.get_build_data()
+    assert set(data.keys()) == {
+        'version', 'formats', 'demuxers', 'muxers', 'codecs', 'bsfs',
+        'protocols', 'filters', 'pix_fmts', 'sample_fmts', 'layouts',
+        'colors', 'devices', 'hw_devices', 'hwaccels'}
+
+    assert isinstance(data['version'], str)
+
+    for fields_key in {'formats', 'demuxers', 'muxers', 'codecs', 'filters'}:
+        assert isinstance(data[fields_key], dict)
+
+    list_keys = {'bsfs'}
+    for list_key in list_keys:
+        assert isinstance(data[list_key], list)
+
+    assert isinstance(data['protocols'], dict)
+    for protocol_key in {'input', 'output'}:
+        assert protocol_key in data['protocols']
+        assert isinstance(data['protocols'][protocol_key], list)
+
+
 def get_filter_complex_input(flt, name):
     m = re.search(r'\[([^]]+)\]{}(?=[[;]|$)'.format(name), flt)
     if m:

From 891ca521fd91d80fd26059fabe20688f24c63199 Mon Sep 17 00:00:00 2001
From: Ross Patterson <me@rpatterson.net>
Date: Wed, 7 Aug 2019 01:38:12 -0700
Subject: [PATCH 03/37] Build data: Fix ffmpeg cmd arg not being passed on

---
 ffmpeg/_build.py | 33 +++++++++++++++++----------------
 1 file changed, 17 insertions(+), 16 deletions(-)

diff --git a/ffmpeg/_build.py b/ffmpeg/_build.py
index f6a59de4..18eca7e0 100644
--- a/ffmpeg/_build.py
+++ b/ffmpeg/_build.py
@@ -13,7 +13,7 @@
 
 parser = argparse.ArgumentParser(description=__doc__)
 parser.add_argument(
-    '--ffmpeg', type=argparse.FileType('r'),
+    '--ffmpeg', default='ffmpeg',
     help='The path to the ffmpeg execuatble')
 
 
@@ -69,6 +69,7 @@ def _run(args):
             process.returncode, process.args, output=stdout, stderr=stderr)
     return stdout.decode()
 
+
 def _get_line_fields(
         stdout, header_lines, line_re, flags={}, int_fields=set()):
     """
@@ -256,21 +257,21 @@ def get_build_data(cmd='ffmpeg'):
     Extract details about the ffmpeg build.
     """
     return dict(
-        version=get_version(cmd='ffmpeg'),
-        formats=get_formats(cmd='ffmpeg'),
-        demuxers=get_demuxers(cmd='ffmpeg'),
-        muxers=get_muxers(cmd='ffmpeg'),
-        codecs=get_codecs(cmd='ffmpeg'),
-        bsfs=get_bsfs(cmd='ffmpeg'),
-        protocols=get_protocols(cmd='ffmpeg'),
-        filters=get_filters(cmd='ffmpeg'),
-        pix_fmts=get_pix_fmts(cmd='ffmpeg'),
-        sample_fmts=get_sample_fmts(cmd='ffmpeg'),
-        layouts=get_layouts(cmd='ffmpeg'),
-        colors=get_colors(cmd='ffmpeg'),
-        devices=get_devices(cmd='ffmpeg'),
-        hw_devices=get_hw_devices(cmd='ffmpeg'),
-        hwaccels=get_hwaccels(cmd='ffmpeg'))
+        version=get_version(cmd=cmd),
+        formats=get_formats(cmd=cmd),
+        demuxers=get_demuxers(cmd=cmd),
+        muxers=get_muxers(cmd=cmd),
+        codecs=get_codecs(cmd=cmd),
+        bsfs=get_bsfs(cmd=cmd),
+        protocols=get_protocols(cmd=cmd),
+        filters=get_filters(cmd=cmd),
+        pix_fmts=get_pix_fmts(cmd=cmd),
+        sample_fmts=get_sample_fmts(cmd=cmd),
+        layouts=get_layouts(cmd=cmd),
+        colors=get_colors(cmd=cmd),
+        devices=get_devices(cmd=cmd),
+        hw_devices=get_hw_devices(cmd=cmd),
+        hwaccels=get_hwaccels(cmd=cmd))
 
 __all__ = [
     'get_build_data',

From f17766aec3978541700b6e23000e9f9e0d09152d Mon Sep 17 00:00:00 2001
From: Ross Patterson <me@rpatterson.net>
Date: Wed, 7 Aug 2019 05:24:09 -0700
Subject: [PATCH 04/37] Detect: Basic hwaccel detection based on OS and GPU,
 Linux only ATM

---
 Makefile                    |  19 ++++++
 examples/get_detect_data.py |  59 ++++++++++++++++++
 ffmpeg/__init__.py          |   3 +
 ffmpeg/_detect.py           | 121 ++++++++++++++++++++++++++++++++++++
 ffmpeg/detect.json          |  71 +++++++++++++++++++++
 setup.py                    |   5 +-
 6 files changed, 276 insertions(+), 2 deletions(-)
 create mode 100644 Makefile
 create mode 100755 examples/get_detect_data.py
 create mode 100644 ffmpeg/_detect.py
 create mode 100644 ffmpeg/detect.json

diff --git a/Makefile b/Makefile
new file mode 100644
index 00000000..49d55b5b
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,19 @@
+## Automate common development tasks
+
+
+.PHONY: default
+defalt: ffmpeg/detect.json
+
+
+.tox/py35/bin/python:
+	tox -e py35
+	touch "$(@)"
+
+.tox/py35/lib/python3.5/site-packages/pandas: .tox/py35/bin/python
+	.tox/py35/bin/pip install requests lxml pandas
+	touch "$(@)"
+
+.PHONY: ffmpeg/detect.json
+ffmpeg/detect.json: .tox/py35/lib/python3.5/site-packages/pandas
+	.tox/py35/bin/python examples/get_detect_data.py >"$(@)"
+
diff --git a/examples/get_detect_data.py b/examples/get_detect_data.py
new file mode 100755
index 00000000..e261a5bf
--- /dev/null
+++ b/examples/get_detect_data.py
@@ -0,0 +1,59 @@
+#!/usr/bin/env python
+"""
+Retrieve and process all the external data for hardware detection.
+"""
+
+import sys
+import json
+
+import requests
+import pandas
+
+HWACCELINTRO_URL = 'https://trac.ffmpeg.org/wiki/HWAccelIntro'
+API_TO_HWACCEL = {
+    'AMF': 'amf',
+    'NVENC/NVDEC/CUVID': 'cuvid',
+    'Direct3D 11': 'd3d11va',
+    'Direct3D 9 (DXVA2)': 'dxva2',
+    'libmfx': 'libmfx',
+    'MediaCodec': 'mediacodec',
+    'Media Foundation': 'mediafoundation',
+    'MMAL': 'mmal',
+    'OpenCL': 'opencl',
+    'OpenMAX': 'omx',
+    'V4L2 M2M': 'v4l2m2m',
+    'VAAPI': 'vaapi',
+    'VDPAU': 'vdpau',
+    'VideoToolbox': 'videotoolbox',
+}
+PLATFORM_TO_PY = {
+    'Apple': 'Darwin',
+}
+
+
+def main():
+    data = {}
+
+    data['hwaccels'] = hwaccels = {}
+    response = requests.get(HWACCELINTRO_URL)
+    api_avail_table, impl_table = pandas.read_html(response.content)
+
+    gpu_vendor_cols = api_avail_table.loc[1][1:]
+    platform_cols = api_avail_table.loc[0][1:]
+    api_rows = api_avail_table[0][2:]
+
+    hwaccels['api_avail'] = platforms = {}
+    for gpu_vendor_idx, gpu_vendor in enumerate(gpu_vendor_cols):
+        platform = platform_cols[gpu_vendor_idx + 1]
+        platform = PLATFORM_TO_PY.get(platform, platform)
+        gpu_vendors = platforms.setdefault(platform, {})
+        avail_hwaccels = gpu_vendors.setdefault(gpu_vendor, [])
+        for api_idx, api in enumerate(api_rows):
+            if api_avail_table[gpu_vendor_idx + 1][api_idx + 2] != 'N':
+                avail_hwaccels.append(API_TO_HWACCEL[api])
+
+    json.dump(data, sys.stdout, indent=2)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/ffmpeg/__init__.py b/ffmpeg/__init__.py
index a3100aa1..1aa61ec9 100644
--- a/ffmpeg/__init__.py
+++ b/ffmpeg/__init__.py
@@ -1,6 +1,7 @@
 from __future__ import unicode_literals
 from . import nodes
 from . import _build
+from . import _detect
 from . import _ffmpeg
 from . import _filters
 from . import _probe
@@ -8,6 +9,7 @@
 from . import _view
 from .nodes import *
 from ._build import *
+from ._detect import *
 from ._ffmpeg import *
 from ._filters import *
 from ._probe import *
@@ -17,6 +19,7 @@
 __all__ = (
     nodes.__all__
     + _build.__all__
+    + _detect.__all__
     + _ffmpeg.__all__
     + _probe.__all__
     + _run.__all__
diff --git a/ffmpeg/_detect.py b/ffmpeg/_detect.py
new file mode 100644
index 00000000..c04081dd
--- /dev/null
+++ b/ffmpeg/_detect.py
@@ -0,0 +1,121 @@
+"""Detect optimal arguments for various options.
+
+This module includes a number of constants used to attempt to detect the
+options which will provide the best performance for a given OS/GPU/etc..
+
+For most of these constants, it only matters that the best performing option
+available for a given OS/platform/hardware rank first for that
+OS/platform/hardware, not which OS/platform/hardware performs better.  For
+example, it doesn't matter if `vdpau` is lower than `cuvid` or vice versa,
+because one is only available for Linux and the other for Windows. Similarly,
+it doesn't matter how `amf` is ranked with respect to `cuvid` because one is
+only available on NVidia GPUs and the other AMD.  It *does* matter how
+`cuvid`/`amf` are ranked with respect to `dxva2` because those could both be
+available on the same OS and GPU.
+
+Additions and suggestions for these constants are very much welcome,
+especially if they come with benchmarks and/or good explanations from those
+who understand this domain well.  Contributions of more complicated or
+involved detection logic may also be welcome, though the case will have to be
+made more rigorously.
+"""
+
+import sys
+import platform
+import os
+import json
+import logging
+import argparse
+import subprocess
+
+import ffmpeg
+
+logger = logging.getLogger(__name__)
+
+parser = argparse.ArgumentParser(description=__doc__)
+parser.add_argument(
+    '--ffmpeg', default='ffmpeg',
+    help='The path to the ffmpeg execuatble')
+
+# List `hwaccel` options by order of expected performance when available.
+HWACCELS_BY_PERFORMANCE = [
+    'cuvid', 'amf', 'vdpau',
+    'qsv', 'd3d11va', 'dxva2', 'vaapi', 'drm']
+# Loaded from JSON
+DATA = None
+
+
+def detect_gpu():
+    """
+    Detect the GPU vendor, generation and model if possible.
+    """
+    plat_sys = platform.system()
+    if plat_sys == 'Linux':
+        display_output = subprocess.check_output(
+            ['lshw', '-class', 'display', '-json'])
+        return json.loads(display_output.decode().strip().strip(','))
+
+
+def detect_hwaccels(hwaccels=None, cmd='ffmpeg'):
+    """
+    Extract details about the ffmpeg build.
+    """
+    # Filter against what's available in the ffmpeg build
+    build_hwaccels = ffmpeg.get_hwaccels(cmd=cmd)
+    if hwaccels is None:
+        # Consider all the available hwaccels
+        hwaccels = build_hwaccels
+    else:
+        # Support passing in a restricted set of hwaccels
+        hwaccels = [
+            hwaccel for hwaccel in hwaccels if hwaccel in build_hwaccels]
+
+    # Filter against which APIs are available on this OS+GPU
+    data = _get_data()
+    plat_sys = platform.system()
+    gpu = detect_gpu()
+    api_avail = data['hwaccels']['api_avail'][plat_sys][
+        gpu['vendor'].replace(' Corporation', '')]
+    hwaccels = [hwaccel for hwaccel in hwaccels if hwaccel in api_avail]
+
+    hwaccels.sort(key=lambda hwaccel: (
+        # Sort unranked hwaccels last, but in the order given by ffmpeg
+        hwaccel not in HWACCELS_BY_PERFORMANCE,
+        (
+            # Sort ranked hwaccels per the constant
+            hwaccel in HWACCELS_BY_PERFORMANCE and
+            HWACCELS_BY_PERFORMANCE.index(hwaccel))))
+    return hwaccels
+
+
+__all__ = [
+    'detect_gpu',
+    'detect_hwaccels',
+]
+
+
+def _get_data():
+    """
+    Don't load the data JSON unless needed, cache in a global.
+    """
+    global DATA
+    if DATA is None:
+        with open(os.path.join(
+                os.path.dirname(__file__), 'detect.json')) as data_opened:
+            DATA = json.load(data_opened)
+    return DATA
+
+
+def main(args=None):
+    """
+    Dump all ffmpeg build data to json.
+    """
+    args = parser.parse_args(args)
+    data = dict(
+        gpu=detect_gpu(),
+        hwaccels=detect_hwaccels(args.ffmpeg))
+    json.dump(data, sys.stdout, indent=2)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/ffmpeg/detect.json b/ffmpeg/detect.json
new file mode 100644
index 00000000..19102f7a
--- /dev/null
+++ b/ffmpeg/detect.json
@@ -0,0 +1,71 @@
+{
+  "hwaccels": {
+    "api_avail": {
+      "Linux": {
+        "AMD": [
+          "opencl",
+          "omx",
+          "vaapi",
+          "vdpau"
+        ],
+        "NVIDIA": [
+          "cuvid",
+          "opencl",
+          "vaapi",
+          "vdpau"
+        ],
+        "Intel": [
+          "libmfx",
+          "opencl",
+          "vaapi"
+        ]
+      },
+      "Darwin": {
+        "iOS": [
+          "videotoolbox"
+        ],
+        "macOS": [
+          "opencl",
+          "videotoolbox"
+        ]
+      },
+      "Android": {
+        "NaN": [
+          "mediacodec",
+          "opencl",
+          "omx",
+          "v4l2m2m"
+        ]
+      },
+      "Other": {
+        "Raspberry Pi": [
+          "mmal",
+          "omx"
+        ]
+      },
+      "Windows": {
+        "AMD": [
+          "amf",
+          "d3d11va",
+          "dxva2",
+          "mediafoundation",
+          "opencl"
+        ],
+        "NVIDIA": [
+          "cuvid",
+          "d3d11va",
+          "dxva2",
+          "mediafoundation",
+          "opencl"
+        ],
+        "Intel": [
+          "d3d11va",
+          "dxva2",
+          "libmfx",
+          "mediafoundation",
+          "opencl"
+        ]
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/setup.py b/setup.py
index da567b8b..1135d0d9 100644
--- a/setup.py
+++ b/setup.py
@@ -95,8 +95,9 @@
         'Programming Language :: Python :: 3.5',
         'Programming Language :: Python :: 3.6',
     ],
-    entry_points = {
+    entry_points={
         'console_scripts': [
-            'ffmpeg-build-json=ffmpeg._build:main'],
+            'ffmpeg-build-json=ffmpeg._build:main',
+            'ffmpeg-detect=ffmpeg._detect:main'],
     },
 )

From fcaab4f3680253584eeb33ebd4501b5802bfd44c Mon Sep 17 00:00:00 2001
From: Ross Patterson <me@rpatterson.net>
Date: Wed, 7 Aug 2019 05:31:35 -0700
Subject: [PATCH 05/37] Project: Use a develop egg for easier development

---
 tox.ini | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tox.ini b/tox.ini
index f86ec4bb..0825210e 100644
--- a/tox.ini
+++ b/tox.ini
@@ -7,6 +7,7 @@
 envlist = py27, py34, py35, py36, pypy
 
 [testenv]
+usedevelop = true
 commands = py.test -vv
 deps =
     future

From 8c16c5242e99f56efe1d7a7d07af25a92bd82c62 Mon Sep 17 00:00:00 2001
From: Ross Patterson <me@rpatterson.net>
Date: Wed, 7 Aug 2019 17:31:28 -0700
Subject: [PATCH 06/37] Detect: Add test for detecting hardware acceleration

---
 ffmpeg/tests/test_ffmpeg.py | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/ffmpeg/tests/test_ffmpeg.py b/ffmpeg/tests/test_ffmpeg.py
index 086a980d..224dfaf1 100644
--- a/ffmpeg/tests/test_ffmpeg.py
+++ b/ffmpeg/tests/test_ffmpeg.py
@@ -740,6 +740,13 @@ def test__build_data():
         assert isinstance(data['protocols'][protocol_key], list)
 
 
+def test__detect():
+    for hwaccels in [
+            ffmpeg.detect_hwaccels(),
+            ffmpeg.detect_hwaccels(['foohwaccel'])]:
+        assert isinstance(hwaccels, list)
+
+
 def get_filter_complex_input(flt, name):
     m = re.search(r'\[([^]]+)\]{}(?=[[;]|$)'.format(name), flt)
     if m:

From 4e08627ef1fa930f82ada06cae39ed9b2af9ace7 Mon Sep 17 00:00:00 2001
From: Ross Patterson <me@rpatterson.net>
Date: Wed, 7 Aug 2019 18:08:56 -0700
Subject: [PATCH 07/37] Detect: Detect accelerated de/encoders based on
 detected hwaccels

---
 ffmpeg/_detect.py           | 63 ++++++++++++++++++++++++++++++++++++-
 ffmpeg/tests/test_ffmpeg.py | 12 +++++++
 2 files changed, 74 insertions(+), 1 deletion(-)

diff --git a/ffmpeg/_detect.py b/ffmpeg/_detect.py
index c04081dd..732226ca 100644
--- a/ffmpeg/_detect.py
+++ b/ffmpeg/_detect.py
@@ -43,6 +43,10 @@
     'qsv', 'd3d11va', 'dxva2', 'vaapi', 'drm']
 # Loaded from JSON
 DATA = None
+# Some accelerated codecs use a different prefix than the base codec
+CODEC_SYNONYMS = {
+    'mpeg1video': 'mpeg1',
+    'mpeg2video': 'mpeg2'}
 
 
 def detect_gpu():
@@ -88,9 +92,65 @@ def detect_hwaccels(hwaccels=None, cmd='ffmpeg'):
     return hwaccels
 
 
+def detect_coder(
+        codec, coder, hwaccels=None, avail_codecs=None, cmd='ffmpeg'):
+    """
+    Determine the optimal decoder/encoder given the hwaccels.
+    """
+    if hwaccels is None:
+        hwaccels = detect_hwaccels(cmd=cmd)
+    if avail_codecs is None:
+        avail_codecs = ffmpeg.get_codecs(cmd=cmd)[codec][coder]
+
+    # Some accelerated codecs use a different prefix than the base codec
+    base_codec = CODEC_SYNONYMS.get(codec, codec)
+
+    # Gather all available accelerated coders for this codec
+    codecs = []
+    for hwaccel in hwaccels:
+        hwaccel_codec = '{0}_{1}'.format(base_codec, hwaccel)
+        if hwaccel_codec in avail_codecs:
+            codecs.append(hwaccel_codec)
+
+    codecs.append(codec)
+    return codecs
+
+
+def detect_codecs(
+        decoder, encoder, hwaccels=None, avail_codecs=None, cmd='ffmpeg'):
+    """
+    Detect the optimal de/encoder for the codec based on the optimal hwaccel.
+    """
+    hwaccels = detect_hwaccels(hwaccels, cmd=cmd)
+
+    build_codecs = ffmpeg.get_codecs(cmd=cmd)
+    build_decoders = build_codecs[decoder]['decoders']
+    build_encoders = build_codecs[encoder]['encoders']
+    if avail_codecs is None:
+        # Consider all the available hwaccels
+        avail_codecs = dict(decoders=build_decoders, encoders=build_encoders)
+    else:
+        # Support passing in restricted sets of decoders and encoders
+        avail_codecs['decoders'] = [
+            codec for codec in avail_codecs['decoders']
+            if codec in build_decoders]
+        avail_codecs['encoders'] = [
+            codec for codec in avail_codecs['encoders']
+            if codec in build_encoders]
+
+    return dict(
+        hwaccels=hwaccels,
+        decoders=detect_coder(
+            decoder, 'decoders', hwaccels, avail_codecs['decoders']),
+        encoders=detect_coder(
+            encoder, 'encoders', hwaccels, avail_codecs['encoders']))
+
+
 __all__ = [
     'detect_gpu',
     'detect_hwaccels',
+    'detect_coder',
+    'detect_codecs',
 ]
 
 
@@ -113,7 +173,8 @@ def main(args=None):
     args = parser.parse_args(args)
     data = dict(
         gpu=detect_gpu(),
-        hwaccels=detect_hwaccels(args.ffmpeg))
+        hwaccels=detect_hwaccels(cmd=args.ffmpeg),
+        codecs=detect_codecs(cmd=args.ffmpeg))
     json.dump(data, sys.stdout, indent=2)
 
 
diff --git a/ffmpeg/tests/test_ffmpeg.py b/ffmpeg/tests/test_ffmpeg.py
index 224dfaf1..0780eac5 100644
--- a/ffmpeg/tests/test_ffmpeg.py
+++ b/ffmpeg/tests/test_ffmpeg.py
@@ -746,6 +746,18 @@ def test__detect():
             ffmpeg.detect_hwaccels(['foohwaccel'])]:
         assert isinstance(hwaccels, list)
 
+    for codecs in [
+            ffmpeg.detect_codecs('h264', 'h264'),
+            ffmpeg.detect_codecs(
+                'h264', 'h264', ['foohwaccel'], dict(
+                    decoders=['bardecoder'], encoders=['quxencoder']))]:
+        assert 'hwaccels' in codecs
+        assert isinstance(codecs['hwaccels'], list)
+        assert 'decoders' in codecs
+        assert isinstance(codecs['decoders'], list)
+        assert 'encoders' in codecs
+        assert isinstance(codecs['encoders'], list)
+
 
 def get_filter_complex_input(flt, name):
     m = re.search(r'\[([^]]+)\]{}(?=[[;]|$)'.format(name), flt)

From 145e57bb7462f7a52e3e7209da5eda5537933848 Mon Sep 17 00:00:00 2001
From: Ross Patterson <me@rpatterson.net>
Date: Fri, 9 Aug 2019 03:06:32 -0700
Subject: [PATCH 08/37] Detect: TODO other platform GPU detection

---
 ffmpeg/_detect.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/ffmpeg/_detect.py b/ffmpeg/_detect.py
index 732226ca..56faee70 100644
--- a/ffmpeg/_detect.py
+++ b/ffmpeg/_detect.py
@@ -55,9 +55,11 @@ def detect_gpu():
     """
     plat_sys = platform.system()
     if plat_sys == 'Linux':
+        # TODO: Android and other Linux'es that don't have `lshw`
         display_output = subprocess.check_output(
             ['lshw', '-class', 'display', '-json'])
         return json.loads(display_output.decode().strip().strip(','))
+    # TODO Other platforms
 
 
 def detect_hwaccels(hwaccels=None, cmd='ffmpeg'):

From ca427cb904d879e2192c600e3ddd64116b52c2ed Mon Sep 17 00:00:00 2001
From: Ross Patterson <me@rpatterson.net>
Date: Fri, 9 Aug 2019 15:09:22 -0700
Subject: [PATCH 09/37] Build: Match the codecs output more closely, better
 semantics

---
 ffmpeg/_build.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/ffmpeg/_build.py b/ffmpeg/_build.py
index 18eca7e0..f76939dd 100644
--- a/ffmpeg/_build.py
+++ b/ffmpeg/_build.py
@@ -140,7 +140,9 @@ def get_codecs(cmd='ffmpeg'):
     codecs = _get_line_fields(stdout, 10, CODEC_RE, CODEC_FLAGS)
     for codec in codecs.values():
         for coders_match in CODEC_CODERS_RE.finditer(codec['description']):
-            codec[coders_match.group(1)] = coders_match.group(3).split()
+            coders = coders_match.group(3).split()
+            if coders:
+                codec[coders_match.group(1)] = coders
         description_match = CODEC_DESCRIPTION_RE.search(codec['description'])
         if description_match is not None:
             codec['description'] = description_match.group('description')

From 130457ffe1fb24f70caa25e4ecd580656992d7a8 Mon Sep 17 00:00:00 2001
From: Ross Patterson <me@rpatterson.net>
Date: Fri, 9 Aug 2019 15:10:29 -0700
Subject: [PATCH 10/37] Build: Include coders specific to hwaccell APIs

---
 ffmpeg/_build.py            | 41 +++++++++++++++++++++++++++++++++----
 ffmpeg/_detect.py           | 23 ++++++++++-----------
 ffmpeg/tests/test_ffmpeg.py | 18 +++++++++++++---
 3 files changed, 63 insertions(+), 19 deletions(-)

diff --git a/ffmpeg/_build.py b/ffmpeg/_build.py
index f76939dd..d75d17f8 100644
--- a/ffmpeg/_build.py
+++ b/ffmpeg/_build.py
@@ -40,6 +40,8 @@
 CODEC_CODERS_RE = re.compile(
     r' \((?P<type>(de|en)coders): (?P<coders>[^)]+) \)')
 
+HWACCEL_SYNONYMS = dict(cuvid=['nvenc', 'nvdec', 'cuda'])
+
 FILTER_RE = re.compile(
     r'^ (?P<timeline>[T.])(?P<slice>[S.])(?P<command>[C.]) '
     r'(?P<name>[^ ]+) +(?P<io>[^ ]+) +(?P<description>.+)$',
@@ -248,22 +250,53 @@ def get_hw_devices(cmd='ffmpeg'):
 
 def get_hwaccels(cmd='ffmpeg'):
     """
-    Extract the hwaccels of the ffmpeg build.
+    Extract the hwaccels of the ffmpeg build, including specific codecs.
+
+    Return all the hardware acceleration APIs supported by this build
+    including all the codecs that are specific to the API.
     """
+    data = dict(codecs=get_codecs(cmd=cmd), hwaccels=[])
+
     stdout = _run([cmd, '-hwaccels'])
-    return stdout.split('\n')[1:-2]
+    hwaccel_names = stdout.split('\n')[1:-2]
+
+    for hwaccel_name in hwaccel_names:
+        hwaccel = dict(name=hwaccel_name)
+        data['hwaccels'].append(hwaccel)
+        hwaccel['codecs'] = hwaccel_codecs = {}
+        for codec_name, codec in data['codecs'].items():
+            hwaccel_codec = {}
+            for coders_key in ('decoders', 'encoders'):
+                matching_coders = []
+                for coder in codec.get(coders_key, []):
+                    for synonym in (
+                            [hwaccel_name] +
+                            HWACCEL_SYNONYMS.get(hwaccel_name, [])):
+                        if (
+                                coder == synonym or
+                                '_' + synonym in coder or
+                                synonym + '_' in coder):
+                            matching_coders.append(coder)
+                            break
+                if matching_coders:
+                    hwaccel_codec[coders_key] = matching_coders
+            if hwaccel_codec:
+                hwaccel_codecs[codec_name] = hwaccel_codec
+
+    return data
 
 
 def get_build_data(cmd='ffmpeg'):
     """
     Extract details about the ffmpeg build.
     """
+    hwaccels_data = get_hwaccels(cmd=cmd)
     return dict(
         version=get_version(cmd=cmd),
         formats=get_formats(cmd=cmd),
         demuxers=get_demuxers(cmd=cmd),
         muxers=get_muxers(cmd=cmd),
-        codecs=get_codecs(cmd=cmd),
+        codecs=hwaccels_data['codecs'],
         bsfs=get_bsfs(cmd=cmd),
         protocols=get_protocols(cmd=cmd),
         filters=get_filters(cmd=cmd),
@@ -273,7 +306,7 @@ def get_build_data(cmd='ffmpeg'):
         colors=get_colors(cmd=cmd),
         devices=get_devices(cmd=cmd),
         hw_devices=get_hw_devices(cmd=cmd),
-        hwaccels=get_hwaccels(cmd=cmd))
+        hwaccels=hwaccels_data['hwaccels'])
 
 __all__ = [
     'get_build_data',
diff --git a/ffmpeg/_detect.py b/ffmpeg/_detect.py
index 56faee70..c4f03671 100644
--- a/ffmpeg/_detect.py
+++ b/ffmpeg/_detect.py
@@ -43,10 +43,6 @@
     'qsv', 'd3d11va', 'dxva2', 'vaapi', 'drm']
 # Loaded from JSON
 DATA = None
-# Some accelerated codecs use a different prefix than the base codec
-CODEC_SYNONYMS = {
-    'mpeg1video': 'mpeg1',
-    'mpeg2video': 'mpeg2'}
 
 
 def detect_gpu():
@@ -67,14 +63,15 @@ def detect_hwaccels(hwaccels=None, cmd='ffmpeg'):
     Extract details about the ffmpeg build.
     """
     # Filter against what's available in the ffmpeg build
-    build_hwaccels = ffmpeg.get_hwaccels(cmd=cmd)
+    hwaccels_data = ffmpeg.get_hwaccels(cmd=cmd)
     if hwaccels is None:
         # Consider all the available hwaccels
-        hwaccels = build_hwaccels
+        hwaccels = hwaccels_data['hwaccels']
     else:
         # Support passing in a restricted set of hwaccels
         hwaccels = [
-            hwaccel for hwaccel in hwaccels if hwaccel in build_hwaccels]
+            hwaccel for hwaccel in hwaccels_data['hwaccels']
+            if hwaccel['name'] in hwaccels]
 
     # Filter against which APIs are available on this OS+GPU
     data = _get_data()
@@ -82,16 +79,18 @@ def detect_hwaccels(hwaccels=None, cmd='ffmpeg'):
     gpu = detect_gpu()
     api_avail = data['hwaccels']['api_avail'][plat_sys][
         gpu['vendor'].replace(' Corporation', '')]
-    hwaccels = [hwaccel for hwaccel in hwaccels if hwaccel in api_avail]
+    hwaccels = [
+        hwaccel for hwaccel in hwaccels if hwaccel['name'] in api_avail]
 
     hwaccels.sort(key=lambda hwaccel: (
         # Sort unranked hwaccels last, but in the order given by ffmpeg
-        hwaccel not in HWACCELS_BY_PERFORMANCE,
+        hwaccel['name'] in HWACCELS_BY_PERFORMANCE and 1 or 0,
         (
             # Sort ranked hwaccels per the constant
-            hwaccel in HWACCELS_BY_PERFORMANCE and
-            HWACCELS_BY_PERFORMANCE.index(hwaccel))))
-    return hwaccels
+            hwaccel['name'] in HWACCELS_BY_PERFORMANCE and
+            HWACCELS_BY_PERFORMANCE.index(hwaccel['name']))))
+    hwaccels_data['hwaccels'] = hwaccels
+    return hwaccels_data
 
 
 def detect_coder(
diff --git a/ffmpeg/tests/test_ffmpeg.py b/ffmpeg/tests/test_ffmpeg.py
index 0780eac5..7f03af8a 100644
--- a/ffmpeg/tests/test_ffmpeg.py
+++ b/ffmpeg/tests/test_ffmpeg.py
@@ -727,7 +727,16 @@ def test__build_data():
 
     assert isinstance(data['version'], str)
 
-    for fields_key in {'formats', 'demuxers', 'muxers', 'codecs', 'filters'}:
+    assert isinstance(data['codecs'], dict)
+    for codec, coders in data['codecs'].items():
+        assert isinstance(codec, str)
+        assert isinstance(coders, dict)
+    assert isinstance(data['hwaccels'], list)
+    for hwaccel in data['hwaccels']:
+        assert isinstance(hwaccel, dict)
+        assert 'name' in hwaccel
+
+    for fields_key in {'formats', 'demuxers', 'muxers', 'filters'}:
         assert isinstance(data[fields_key], dict)
 
     list_keys = {'bsfs'}
@@ -741,10 +750,13 @@ def test__build_data():
 
 
 def test__detect():
-    for hwaccels in [
+    for hwaccels_data in [
             ffmpeg.detect_hwaccels(),
             ffmpeg.detect_hwaccels(['foohwaccel'])]:
-        assert isinstance(hwaccels, list)
+        assert isinstance(hwaccels_data['hwaccels'], list)
+        for hwaccel in hwaccels_data['hwaccels']:
+            assert isinstance(hwaccel, dict)
+            assert 'name' in hwaccel
 
     for codecs in [
             ffmpeg.detect_codecs('h264', 'h264'),

From c70a3f9cae37aa68b7766c1c37e6f6c2fae63b8b Mon Sep 17 00:00:00 2001
From: Ross Patterson <me@rpatterson.net>
Date: Fri, 9 Aug 2019 17:00:42 -0700
Subject: [PATCH 11/37] Detect: Improve docstrings

---
 ffmpeg/_detect.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/ffmpeg/_detect.py b/ffmpeg/_detect.py
index c4f03671..d4c38f68 100644
--- a/ffmpeg/_detect.py
+++ b/ffmpeg/_detect.py
@@ -60,7 +60,7 @@ def detect_gpu():
 
 def detect_hwaccels(hwaccels=None, cmd='ffmpeg'):
     """
-    Extract details about the ffmpeg build.
+    Order the available hardware accelerations by performance.
     """
     # Filter against what's available in the ffmpeg build
     hwaccels_data = ffmpeg.get_hwaccels(cmd=cmd)
@@ -96,7 +96,7 @@ def detect_hwaccels(hwaccels=None, cmd='ffmpeg'):
 def detect_coder(
         codec, coder, hwaccels=None, avail_codecs=None, cmd='ffmpeg'):
     """
-    Determine the optimal decoder/encoder given the hwaccels.
+    Detect the optimal decoders and encoders on the optimal hwaccel.
     """
     if hwaccels is None:
         hwaccels = detect_hwaccels(cmd=cmd)

From 69caa25e5294c7cf034050c6664ce3266b4fc928 Mon Sep 17 00:00:00 2001
From: Ross Patterson <me@rpatterson.net>
Date: Fri, 9 Aug 2019 17:01:40 -0700
Subject: [PATCH 12/37] Detect: List available input/output kwargs in order of
 performance

---
 ffmpeg/_detect.py           | 92 +++++++++++++++++--------------------
 ffmpeg/tests/test_ffmpeg.py | 16 +++----
 2 files changed, 49 insertions(+), 59 deletions(-)

diff --git a/ffmpeg/_detect.py b/ffmpeg/_detect.py
index d4c38f68..4c8891d4 100644
--- a/ffmpeg/_detect.py
+++ b/ffmpeg/_detect.py
@@ -23,6 +23,7 @@
 import sys
 import platform
 import os
+import copy
 import json
 import logging
 import argparse
@@ -93,64 +94,55 @@ def detect_hwaccels(hwaccels=None, cmd='ffmpeg'):
     return hwaccels_data
 
 
-def detect_coder(
-        codec, coder, hwaccels=None, avail_codecs=None, cmd='ffmpeg'):
+def detect_codecs(decoder, encoder, hwaccels=None, cmd='ffmpeg'):
     """
     Detect the optimal decoders and encoders on the optimal hwaccel.
     """
-    if hwaccels is None:
-        hwaccels = detect_hwaccels(cmd=cmd)
-    if avail_codecs is None:
-        avail_codecs = ffmpeg.get_codecs(cmd=cmd)[codec][coder]
-
-    # Some accelerated codecs use a different prefix than the base codec
-    base_codec = CODEC_SYNONYMS.get(codec, codec)
-
-    # Gather all available accelerated coders for this codec
-    codecs = []
-    for hwaccel in hwaccels:
-        hwaccel_codec = '{0}_{1}'.format(base_codec, hwaccel)
-        if hwaccel_codec in avail_codecs:
-            codecs.append(hwaccel_codec)
-
-    codecs.append(codec)
-    return codecs
-
-
-def detect_codecs(
-        decoder, encoder, hwaccels=None, avail_codecs=None, cmd='ffmpeg'):
-    """
-    Detect the optimal de/encoder for the codec based on the optimal hwaccel.
-    """
-    hwaccels = detect_hwaccels(hwaccels, cmd=cmd)
-
-    build_codecs = ffmpeg.get_codecs(cmd=cmd)
-    build_decoders = build_codecs[decoder]['decoders']
-    build_encoders = build_codecs[encoder]['encoders']
-    if avail_codecs is None:
-        # Consider all the available hwaccels
-        avail_codecs = dict(decoders=build_decoders, encoders=build_encoders)
-    else:
-        # Support passing in restricted sets of decoders and encoders
-        avail_codecs['decoders'] = [
-            codec for codec in avail_codecs['decoders']
-            if codec in build_decoders]
-        avail_codecs['encoders'] = [
-            codec for codec in avail_codecs['encoders']
-            if codec in build_encoders]
-
-    return dict(
-        hwaccels=hwaccels,
-        decoders=detect_coder(
-            decoder, 'decoders', hwaccels, avail_codecs['decoders']),
-        encoders=detect_coder(
-            encoder, 'encoders', hwaccels, avail_codecs['encoders']))
+    hwaccels_data = detect_hwaccels(hwaccels, cmd=cmd)
+
+    build_codecs = hwaccels_data['codecs']
+    avail_decoders = build_codecs[decoder]['decoders']
+    avail_encoders = build_codecs[encoder]['encoders']
+
+    codecs_kwargs = []
+    default_kwargs = dict(output=dict(codec=avail_encoders[0]))
+    for hwaccel in hwaccels_data['hwaccels']:
+
+        if hwaccel['codecs']:
+            # This hwaccel requires specific coders.
+            for hwaccel_encoder in hwaccel['codecs'].get(
+                    encoder, {}).get('encoders', []):
+                # We have an accelerated encoder, include it.
+                # Remove hwaccel codecs from future consideration.
+                hwaccel_encoder = hwaccel_encoder
+                avail_encoders.remove(hwaccel_encoder)
+                hwaccel_kwargs = dict(
+                    input=dict(hwaccel=hwaccel['name']),
+                    output=dict(codec=hwaccel_encoder))
+                codecs_kwargs.append(hwaccel_kwargs)
+                for hwaccel_decoder in hwaccel['codecs'].get(
+                        decoder, {}).get('decoders', []):
+                    if hwaccel_decoder in avail_decoders:
+                        # We have an accelerated decoder, can make a minor but
+                        # significant difference.
+                        # Remove hwaccel codecs from future consideration.
+                        hwaccel_kwargs['input']['codec'] = hwaccel_decoder
+                        avail_decoders.remove(hwaccel_decoder)
+                # Otherwise let ffmpeg choose the decoder
+
+        else:
+            # This hwaccel doesn't require specific coders.
+            hwaccel_kwargs = copy.deepcopy(default_kwargs)
+            hwaccel_kwargs['input'] = dict(hwaccel=hwaccel['name'])
+            codecs_kwargs.append(hwaccel_kwargs)
+
+    codecs_kwargs.append(default_kwargs)
+    return codecs_kwargs
 
 
 __all__ = [
     'detect_gpu',
     'detect_hwaccels',
-    'detect_coder',
     'detect_codecs',
 ]
 
diff --git a/ffmpeg/tests/test_ffmpeg.py b/ffmpeg/tests/test_ffmpeg.py
index 7f03af8a..6ecf6bb0 100644
--- a/ffmpeg/tests/test_ffmpeg.py
+++ b/ffmpeg/tests/test_ffmpeg.py
@@ -758,17 +758,15 @@ def test__detect():
             assert isinstance(hwaccel, dict)
             assert 'name' in hwaccel
 
-    for codecs in [
+    for codecs_kwargs in [
             ffmpeg.detect_codecs('h264', 'h264'),
             ffmpeg.detect_codecs(
-                'h264', 'h264', ['foohwaccel'], dict(
-                    decoders=['bardecoder'], encoders=['quxencoder']))]:
-        assert 'hwaccels' in codecs
-        assert isinstance(codecs['hwaccels'], list)
-        assert 'decoders' in codecs
-        assert isinstance(codecs['decoders'], list)
-        assert 'encoders' in codecs
-        assert isinstance(codecs['encoders'], list)
+                'h264', 'h264', ['foohwaccel'])]:
+        for codec_kwargs in codecs_kwargs:
+            assert 'output' in codec_kwargs
+            assert isinstance(codec_kwargs['output'], dict)
+            assert 'codec' in codec_kwargs['output']
+            assert isinstance(codec_kwargs['output']['codec'], str)
 
 
 def get_filter_complex_input(flt, name):

From 8490da9fb653eb2c4c684312c4f307666a6295c0 Mon Sep 17 00:00:00 2001
From: Ross Patterson <me@rpatterson.net>
Date: Fri, 9 Aug 2019 17:30:28 -0700
Subject: [PATCH 13/37] Detect: Raise meaningful errors when no decoder/encoder
 can be found

---
 ffmpeg/_detect.py | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/ffmpeg/_detect.py b/ffmpeg/_detect.py
index 4c8891d4..8d796cdb 100644
--- a/ffmpeg/_detect.py
+++ b/ffmpeg/_detect.py
@@ -101,8 +101,15 @@ def detect_codecs(decoder, encoder, hwaccels=None, cmd='ffmpeg'):
     hwaccels_data = detect_hwaccels(hwaccels, cmd=cmd)
 
     build_codecs = hwaccels_data['codecs']
-    avail_decoders = build_codecs[decoder]['decoders']
-    avail_encoders = build_codecs[encoder]['encoders']
+
+    avail_decoders = build_codecs.get(decoder, {}).get('decoders', [])
+    avail_encoders = build_codecs.get(encoder, {}).get('encoders', [])
+    if not avail_decoders:
+        raise ValueError(
+            'Could not detect a supported decoder for {0!r}'.format(decoder))
+    if not avail_encoders:
+        raise ValueError(
+            'Could not detect a supported encoder for {0!r}'.format(encoder))
 
     codecs_kwargs = []
     default_kwargs = dict(output=dict(codec=avail_encoders[0]))

From dc243a6e9cc06e73836f0039e582195c28ae40ad Mon Sep 17 00:00:00 2001
From: Ross Patterson <me@rpatterson.net>
Date: Fri, 9 Aug 2019 17:38:23 -0700
Subject: [PATCH 14/37] Tests: Add recent Pythons for testing, remove Python
 3.6

Python 3.6 was kinda skipped by many and isn't available in the Ubuntu
deadsnakes repository.
---
 Makefile | 12 ++++++------
 tox.ini  |  2 +-
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/Makefile b/Makefile
index 49d55b5b..1178a7a3 100644
--- a/Makefile
+++ b/Makefile
@@ -5,15 +5,15 @@
 defalt: ffmpeg/detect.json
 
 
-.tox/py35/bin/python:
-	tox -e py35
+.tox/py38/bin/python:
+	tox -e py38
 	touch "$(@)"
 
-.tox/py35/lib/python3.5/site-packages/pandas: .tox/py35/bin/python
-	.tox/py35/bin/pip install requests lxml pandas
+.tox/py38/lib/python3.8/site-packages/pandas: .tox/py38/bin/python
+	.tox/py38/bin/pip install requests lxml pandas
 	touch "$(@)"
 
 .PHONY: ffmpeg/detect.json
-ffmpeg/detect.json: .tox/py35/lib/python3.5/site-packages/pandas
-	.tox/py35/bin/python examples/get_detect_data.py >"$(@)"
+ffmpeg/detect.json: .tox/py38/lib/python3.8/site-packages/pandas
+	.tox/py38/bin/python examples/get_detect_data.py >"$(@)"
 
diff --git a/tox.ini b/tox.ini
index 0825210e..1f64f2d4 100644
--- a/tox.ini
+++ b/tox.ini
@@ -4,7 +4,7 @@
 # and then run "tox" from this directory.
 
 [tox]
-envlist = py27, py34, py35, py36, pypy
+envlist = py27, py34, py35, py37, py38, pypy
 
 [testenv]
 usedevelop = true

From a3e784b0d1d1c7538ef5e34e7e782f2dcef7d55e Mon Sep 17 00:00:00 2001
From: Ross Patterson <me@rpatterson.net>
Date: Fri, 9 Aug 2019 18:30:22 -0700
Subject: [PATCH 15/37] Detect: Fix VAAPI handling, add -hwaccel_output_format
 handling

---
 ffmpeg/_detect.py | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

diff --git a/ffmpeg/_detect.py b/ffmpeg/_detect.py
index 8d796cdb..76d447a1 100644
--- a/ffmpeg/_detect.py
+++ b/ffmpeg/_detect.py
@@ -40,8 +40,17 @@
 
 # List `hwaccel` options by order of expected performance when available.
 HWACCELS_BY_PERFORMANCE = [
-    'cuvid', 'amf', 'vdpau',
-    'qsv', 'd3d11va', 'dxva2', 'vaapi', 'drm']
+    # NVidia
+    'nvdec', 'cuvid', 'cuda',
+    # AMD
+    'amf',
+    # Windows
+    'qsv', 'd3d11va', 'dxva2',
+    # Linux
+    'vaapi', 'vdpau', 'drm']
+HWACCEL_OUTPUT_FORMATS = {
+    'nvdec': 'cuda',
+    'vaapi': 'vaapi'}
 # Loaded from JSON
 DATA = None
 
@@ -126,6 +135,9 @@ def detect_codecs(decoder, encoder, hwaccels=None, cmd='ffmpeg'):
                 hwaccel_kwargs = dict(
                     input=dict(hwaccel=hwaccel['name']),
                     output=dict(codec=hwaccel_encoder))
+                if hwaccel['name'] in HWACCEL_OUTPUT_FORMATS:
+                    hwaccel_kwargs['input']['hwaccel_output_format'] = (
+                        HWACCEL_OUTPUT_FORMATS[hwaccel['name']])
                 codecs_kwargs.append(hwaccel_kwargs)
                 for hwaccel_decoder in hwaccel['codecs'].get(
                         decoder, {}).get('decoders', []):

From 79b19eba7283af34279b4b7c58af5041ed456409 Mon Sep 17 00:00:00 2001
From: Ross Patterson <me@rpatterson.net>
Date: Fri, 9 Aug 2019 19:00:12 -0700
Subject: [PATCH 16/37] Detect: Factor out hwaccel detection data download

---
 examples/get_detect_data.py | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

diff --git a/examples/get_detect_data.py b/examples/get_detect_data.py
index e261a5bf..1dd724c4 100755
--- a/examples/get_detect_data.py
+++ b/examples/get_detect_data.py
@@ -31,10 +31,11 @@
 }
 
 
-def main():
-    data = {}
 
-    data['hwaccels'] = hwaccels = {}
+def get_hwaccel_data():
+    """
+    Download the ffmpeg hwaccel API support matrix to detection data.
+    """
     response = requests.get(HWACCELINTRO_URL)
     api_avail_table, impl_table = pandas.read_html(response.content)
 
@@ -42,6 +43,7 @@ def main():
     platform_cols = api_avail_table.loc[0][1:]
     api_rows = api_avail_table[0][2:]
 
+    hwaccels = {}
     hwaccels['api_avail'] = platforms = {}
     for gpu_vendor_idx, gpu_vendor in enumerate(gpu_vendor_cols):
         platform = platform_cols[gpu_vendor_idx + 1]
@@ -52,6 +54,14 @@ def main():
             if api_avail_table[gpu_vendor_idx + 1][api_idx + 2] != 'N':
                 avail_hwaccels.append(API_TO_HWACCEL[api])
 
+    return hwaccels
+
+
+def main():
+    """
+    Download ffmpeg detection data.
+    """
+    data = dict(hwaccels=get_hwaccel_data())
     json.dump(data, sys.stdout, indent=2)
 
 

From 3ba9598c19988ee08e4377c5ac9931a4ebe35ad0 Mon Sep 17 00:00:00 2001
From: Ross Patterson <me@rpatterson.net>
Date: Fri, 9 Aug 2019 20:19:56 -0700
Subject: [PATCH 17/37] Detect: Improve handling of undetected platforms

---
 ffmpeg/_detect.py | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

diff --git a/ffmpeg/_detect.py b/ffmpeg/_detect.py
index 76d447a1..8bf3a860 100644
--- a/ffmpeg/_detect.py
+++ b/ffmpeg/_detect.py
@@ -60,12 +60,22 @@ def detect_gpu():
     Detect the GPU vendor, generation and model if possible.
     """
     plat_sys = platform.system()
+    gpu = None
+
     if plat_sys == 'Linux':
         # TODO: Android and other Linux'es that don't have `lshw`
         display_output = subprocess.check_output(
             ['lshw', '-class', 'display', '-json'])
-        return json.loads(display_output.decode().strip().strip(','))
-    # TODO Other platforms
+        display_data = json.loads(display_output.decode().strip().strip(','))
+        gpu = dict(
+            vendor=display_data['vendor'].replace(' Corporation', ''))
+
+    else:
+        # TODO Other platforms
+        raise NotImplementedError(
+            'GPU detection for {0!r} not supported yet'.format(plat_sys))
+
+    return gpu
 
 
 def detect_hwaccels(hwaccels=None, cmd='ffmpeg'):
@@ -87,8 +97,7 @@ def detect_hwaccels(hwaccels=None, cmd='ffmpeg'):
     data = _get_data()
     plat_sys = platform.system()
     gpu = detect_gpu()
-    api_avail = data['hwaccels']['api_avail'][plat_sys][
-        gpu['vendor'].replace(' Corporation', '')]
+    api_avail = data['hwaccels']['api_avail'][plat_sys][gpu['vendor']]
     hwaccels = [
         hwaccel for hwaccel in hwaccels if hwaccel['name'] in api_avail]
 

From 7781c9c7b4d3968cf7a8940f2dd13debaaa7473a Mon Sep 17 00:00:00 2001
From: Ross Patterson <me@rpatterson.net>
Date: Fri, 9 Aug 2019 20:24:06 -0700
Subject: [PATCH 18/37] Detect: GPU, add Linux board and chip detection

---
 ffmpeg/_detect.py | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/ffmpeg/_detect.py b/ffmpeg/_detect.py
index 8bf3a860..32f9422d 100644
--- a/ffmpeg/_detect.py
+++ b/ffmpeg/_detect.py
@@ -24,6 +24,7 @@
 import platform
 import os
 import copy
+import re
 import json
 import logging
 import argparse
@@ -51,6 +52,9 @@
 HWACCEL_OUTPUT_FORMATS = {
     'nvdec': 'cuda',
     'vaapi': 'vaapi'}
+
+GPU_PRODUCT_RE = re.compile(r'(?P<chip>[^[]+)(\[(?P<board>[^]]+)\]|)')
+
 # Loaded from JSON
 DATA = None
 
@@ -70,6 +74,12 @@ def detect_gpu():
         gpu = dict(
             vendor=display_data['vendor'].replace(' Corporation', ''))
 
+        product_match = GPU_PRODUCT_RE.search(display_data['product'])
+        if product_match:
+            gpu.update(**product_match.groupdict())
+            if not gpu['board']:
+                gpu['board'] = gpu.pop('chip')
+
     else:
         # TODO Other platforms
         raise NotImplementedError(

From d7ae12f04b76d42d4d8dd321af5b8ea42f4ce7f8 Mon Sep 17 00:00:00 2001
From: Ross Patterson <me@rpatterson.net>
Date: Fri, 9 Aug 2019 20:48:34 -0700
Subject: [PATCH 19/37] Detect: Add multiple GPU handling

---
 ffmpeg/_detect.py | 45 ++++++++++++++++++++++++++++-----------------
 1 file changed, 28 insertions(+), 17 deletions(-)

diff --git a/ffmpeg/_detect.py b/ffmpeg/_detect.py
index 32f9422d..bcb63aac 100644
--- a/ffmpeg/_detect.py
+++ b/ffmpeg/_detect.py
@@ -59,33 +59,41 @@
 DATA = None
 
 
-def detect_gpu():
+def detect_gpus():
     """
-    Detect the GPU vendor, generation and model if possible.
+    Detect the vendor, generation and model for each GPU if possible.
     """
     plat_sys = platform.system()
-    gpu = None
+    gpus = []
 
     if plat_sys == 'Linux':
         # TODO: Android and other Linux'es that don't have `lshw`
         display_output = subprocess.check_output(
             ['lshw', '-class', 'display', '-json'])
-        display_data = json.loads(display_output.decode().strip().strip(','))
-        gpu = dict(
-            vendor=display_data['vendor'].replace(' Corporation', ''))
-
-        product_match = GPU_PRODUCT_RE.search(display_data['product'])
-        if product_match:
-            gpu.update(**product_match.groupdict())
-            if not gpu['board']:
-                gpu['board'] = gpu.pop('chip')
+        displays_data = json.loads(display_output.decode().strip().strip(','))
+        if not isinstance(displays_data, list):
+            # TODO: Confirm this is how `lshw` handles multiple GPUs
+            displays_data = [displays_data]
+        for display_data in displays_data:
+            gpu = dict(
+                vendor=display_data['vendor'].replace(' Corporation', ''))
+            # TODO get multiple GPUs from lshw
+            gpus.append(gpu)
+
+            product_match = GPU_PRODUCT_RE.search(display_data['product'])
+            if product_match:
+                gpu.update(**product_match.groupdict())
+                if not gpu['board']:
+                    gpu['board'] = gpu.pop('chip')
 
     else:
         # TODO Other platforms
         raise NotImplementedError(
             'GPU detection for {0!r} not supported yet'.format(plat_sys))
 
-    return gpu
+    if not gpus:
+        raise ValueError('No GPUs detected')
+    return gpus
 
 
 def detect_hwaccels(hwaccels=None, cmd='ffmpeg'):
@@ -106,8 +114,11 @@ def detect_hwaccels(hwaccels=None, cmd='ffmpeg'):
     # Filter against which APIs are available on this OS+GPU
     data = _get_data()
     plat_sys = platform.system()
-    gpu = detect_gpu()
-    api_avail = data['hwaccels']['api_avail'][plat_sys][gpu['vendor']]
+    gpus = detect_gpus()
+    api_avail = set()
+    for gpu in gpus:
+        api_avail.update(
+            data['hwaccels']['api_avail'][plat_sys][gpu['vendor']])
     hwaccels = [
         hwaccel for hwaccel in hwaccels if hwaccel['name'] in api_avail]
 
@@ -179,7 +190,7 @@ def detect_codecs(decoder, encoder, hwaccels=None, cmd='ffmpeg'):
 
 
 __all__ = [
-    'detect_gpu',
+    'detect_gpus',
     'detect_hwaccels',
     'detect_codecs',
 ]
@@ -203,7 +214,7 @@ def main(args=None):
     """
     args = parser.parse_args(args)
     data = dict(
-        gpu=detect_gpu(),
+        gpus=detect_gpus(),
         hwaccels=detect_hwaccels(cmd=args.ffmpeg),
         codecs=detect_codecs(cmd=args.ffmpeg))
     json.dump(data, sys.stdout, indent=2)

From 7121906e62de273ea7d6174c363098d42298685c Mon Sep 17 00:00:00 2001
From: Ross Patterson <me@rpatterson.net>
Date: Fri, 9 Aug 2019 20:49:11 -0700
Subject: [PATCH 20/37] Detect: Use easier Python version for requirements
 building

---
 Makefile | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/Makefile b/Makefile
index 1178a7a3..2f917821 100644
--- a/Makefile
+++ b/Makefile
@@ -5,15 +5,15 @@
 defalt: ffmpeg/detect.json
 
 
-.tox/py38/bin/python:
-	tox -e py38
+.tox/py37/bin/python:
+	tox -e py37
 	touch "$(@)"
 
-.tox/py38/lib/python3.8/site-packages/pandas: .tox/py38/bin/python
-	.tox/py38/bin/pip install requests lxml pandas
+.tox/py37/lib/python3.7/site-packages/pandas: .tox/py37/bin/python
+	.tox/py37/bin/pip install requests lxml pandas
 	touch "$(@)"
 
 .PHONY: ffmpeg/detect.json
-ffmpeg/detect.json: .tox/py38/lib/python3.8/site-packages/pandas
-	.tox/py38/bin/python examples/get_detect_data.py >"$(@)"
+ffmpeg/detect.json: .tox/py37/lib/python3.7/site-packages/pandas
+	.tox/py37/bin/python examples/get_detect_data.py >"$(@)"
 

From 999d047bfeae1c3a3c82cd2525fb877e497d6182 Mon Sep 17 00:00:00 2001
From: Ross Patterson <me@rpatterson.net>
Date: Fri, 9 Aug 2019 21:30:48 -0700
Subject: [PATCH 21/37] Detect: Checkpoint untested Windows GPU detection

---
 ffmpeg/_detect.py | 13 +++++++++++++
 setup.py          |  3 +++
 2 files changed, 16 insertions(+)

diff --git a/ffmpeg/_detect.py b/ffmpeg/_detect.py
index bcb63aac..c88644bc 100644
--- a/ffmpeg/_detect.py
+++ b/ffmpeg/_detect.py
@@ -54,6 +54,8 @@
     'vaapi': 'vaapi'}
 
 GPU_PRODUCT_RE = re.compile(r'(?P<chip>[^[]+)(\[(?P<board>[^]]+)\]|)')
+GPU_WMI_PROPERTIES = dict(
+    vendor='AdapterCompatibility', board='VideoProcessor')
 
 # Loaded from JSON
 DATA = None
@@ -86,6 +88,17 @@ def detect_gpus():
                 if not gpu['board']:
                     gpu['board'] = gpu.pop('chip')
 
+    elif plat_sys == 'Windows':
+        import wmi
+        for controller in wmi.WMI().Win32_VideoController():
+            gpu = {}
+            for key, wmi_prop in GPU_WMI_PROPERTIES.items():
+                value = controller.wmi_property(wmi_prop).value
+                if value:
+                    gpu[key] = value
+            if gpu:
+                gpus.append(gpu)
+
     else:
         # TODO Other platforms
         raise NotImplementedError(
diff --git a/setup.py b/setup.py
index 1135d0d9..a661f918 100644
--- a/setup.py
+++ b/setup.py
@@ -72,6 +72,9 @@
     long_description=long_description,
     install_requires=['future'],
     extras_require={
+        'detect': [
+            "pywin32; sys_platform == 'Windows'",
+            "wmi; sys_platform == 'Windows'"],
         'dev': [
             'future==0.17.1',
             'numpy==1.16.4',

From c46f24848e629effaf12508620a1d385afa1a305 Mon Sep 17 00:00:00 2001
From: Ross Patterson <me@rpatterson.net>
Date: Fri, 9 Aug 2019 21:34:08 -0700
Subject: [PATCH 22/37] Detect: Improve constants order, more general first

---
 examples/get_detect_data.py | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/examples/get_detect_data.py b/examples/get_detect_data.py
index 1dd724c4..66867052 100755
--- a/examples/get_detect_data.py
+++ b/examples/get_detect_data.py
@@ -9,6 +9,10 @@
 import requests
 import pandas
 
+PLATFORM_TO_PY = {
+    'Apple': 'Darwin',
+}
+
 HWACCELINTRO_URL = 'https://trac.ffmpeg.org/wiki/HWAccelIntro'
 API_TO_HWACCEL = {
     'AMF': 'amf',
@@ -26,9 +30,6 @@
     'VDPAU': 'vdpau',
     'VideoToolbox': 'videotoolbox',
 }
-PLATFORM_TO_PY = {
-    'Apple': 'Darwin',
-}
 
 
 

From 769d45b7ad7f00667d4053704793d3220c4bb25f Mon Sep 17 00:00:00 2001
From: Ross Patterson <me@rpatterson.net>
Date: Sat, 10 Aug 2019 04:02:41 -0700
Subject: [PATCH 23/37] Detect: Parse multiple boards into model lines and
 model numbers

---
 ffmpeg/_detect.py           | 71 +++++++++++++++++++++++++++++++++++++
 ffmpeg/tests/test_ffmpeg.py | 22 ++++++++++++
 2 files changed, 93 insertions(+)

diff --git a/ffmpeg/_detect.py b/ffmpeg/_detect.py
index c88644bc..bf22797c 100644
--- a/ffmpeg/_detect.py
+++ b/ffmpeg/_detect.py
@@ -39,6 +39,9 @@
     '--ffmpeg', default='ffmpeg',
     help='The path to the ffmpeg execuatble')
 
+# Separators to divide a range of models within a line
+MODEL_RANGE_SEPARATORS = ['-', '>']
+
 # List `hwaccel` options by order of expected performance when available.
 HWACCELS_BY_PERFORMANCE = [
     # NVidia
@@ -106,6 +109,18 @@ def detect_gpus():
 
     if not gpus:
         raise ValueError('No GPUs detected')
+
+    data = _get_data()
+    for gpu in gpus:
+        vendor_data = data.get(gpu.get('vendor', '').lower())
+        if vendor_data:
+            model_lines_data = _parse_models(
+                model_lines=vendor_data['lines'],
+                boards=gpu['board'].lower(), model_data={})
+            gpu['model_line'] = list(model_lines_data.keys())[0]
+            gpu['model_num'] = list(model_lines_data[
+                gpu['model_line']]['models'].keys())[0]
+
     return gpus
 
 
@@ -221,6 +236,62 @@ def _get_data():
     return DATA
 
 
+def _parse_models(
+        model_lines, boards, model_data,
+        model_lines_data=None, model_line=None):
+    """
+    Parse model lines, sets and ranges from a boards string.
+    """
+    if model_lines_data is None:
+        model_lines_data = {}
+
+    boards = boards.strip().lower()
+    model_line_positions = [
+        (boards.index(next_model_line), idx, next_model_line)
+        for idx, next_model_line in enumerate(model_lines)
+        if next_model_line in boards]
+    if model_line_positions:
+        pos, idx, next_model_line = min(model_line_positions)
+        model_group, next_boards = boards.split(next_model_line.lower(), 1)
+    else:
+        model_group = boards
+        next_boards = ''
+
+    model_group = model_group.strip()
+    if model_group:
+        # First item is a model range for the previous model line
+        model_line_data = model_lines_data.setdefault(
+            model_line, dict(models={}, model_ranges=[]))
+
+        models = []
+        for model_split in model_group.split('/'):
+            models.extend(
+                model.strip()
+                for model in model_split.split('+'))
+
+        for model_range in models:
+            for model_range_separator in MODEL_RANGE_SEPARATORS:
+                model_range_parameters = model_range.split(
+                    model_range_separator)
+                if len(model_range_parameters) > 1:
+                    # This is a range of models
+                    model_line_data['model_ranges'].append(
+                        [model_range, model_data])
+                    models.remove(model_range)
+                    break
+            else:
+                model_line_data['models'][model_range] = model_data
+
+    next_boards = next_boards.strip()
+    if next_boards:
+        return _parse_models(
+            model_lines=model_lines, boards=next_boards,
+            model_data=model_data, model_lines_data=model_lines_data,
+            model_line=next_model_line)
+
+    return model_lines_data
+
+
 def main(args=None):
     """
     Dump all ffmpeg build data to json.
diff --git a/ffmpeg/tests/test_ffmpeg.py b/ffmpeg/tests/test_ffmpeg.py
index 6ecf6bb0..e27b4e64 100644
--- a/ffmpeg/tests/test_ffmpeg.py
+++ b/ffmpeg/tests/test_ffmpeg.py
@@ -769,6 +769,28 @@ def test__detect():
             assert isinstance(codec_kwargs['output']['codec'], str)
 
 
+def test__detect_parse_models():
+    """
+    Parse model lines, sets and ranges.
+    """
+    model_lines = ffmpeg._detect._parse_models(
+        model_lines=['geforce rtx', 'geforce gtx', 'geforce gt', 'geforce'],
+        boards=(
+            'GeForce GT 630 > 640 GeForce GTX 650 / 660 '
+            'GeForce GT 740+750'),
+        model_data={})
+    assert 'geforce gt' in model_lines
+    assert 'models' in model_lines['geforce gt']
+    assert '740' in model_lines['geforce gt']['models']
+    assert '750' in model_lines['geforce gt']['models']
+    assert 'model_ranges' in model_lines['geforce gt']
+    assert '630 > 640' in model_lines['geforce gt']['model_ranges'][0]
+    assert 'geforce gtx' in model_lines
+    assert 'models' in model_lines['geforce gtx']
+    assert '650' in model_lines['geforce gtx']['models']
+    assert '660' in model_lines['geforce gtx']['models']
+
+
 def get_filter_complex_input(flt, name):
     m = re.search(r'\[([^]]+)\]{}(?=[[;]|$)'.format(name), flt)
     if m:

From d084c3887562655f5b3d62911f0bc78a4a60efbb Mon Sep 17 00:00:00 2001
From: Ross Patterson <me@rpatterson.net>
Date: Sat, 10 Aug 2019 06:39:17 -0700
Subject: [PATCH 24/37] Detect: Add NVidia model decoder data

---
 examples/get_detect_data.py |   95 +-
 ffmpeg/_detect.py           |   10 +-
 ffmpeg/detect.json          | 2221 ++++++++++++++++++++++++++++++++++-
 3 files changed, 2291 insertions(+), 35 deletions(-)

diff --git a/examples/get_detect_data.py b/examples/get_detect_data.py
index 66867052..74d79627 100755
--- a/examples/get_detect_data.py
+++ b/examples/get_detect_data.py
@@ -4,11 +4,14 @@
 """
 
 import sys
+import math
 import json
 
 import requests
 import pandas
 
+from ffmpeg import _detect
+
 PLATFORM_TO_PY = {
     'Apple': 'Darwin',
 }
@@ -31,6 +34,10 @@
     'VideoToolbox': 'videotoolbox',
 }
 
+NVIDIA_GPU_MATRIX_URL = (
+    'https://developer.nvidia.com/video-encode-decode-gpu-support-matrix')
+NVIDIA_LINE_SUFFIXES = {'geforce': ['gtx titan', 'gtx', 'gt', 'rtx']}
+NVIDIA_CODEC_COLUMN_PREFIXES = {'h.264': 'h264', 'h.265': 'hevc'}
 
 
 def get_hwaccel_data():
@@ -58,11 +65,97 @@ def get_hwaccel_data():
     return hwaccels
 
 
+def get_nvidia_data():
+    """
+    Download the NVIDIA GPU support matrix to detection data.
+    """
+    response = requests.get(NVIDIA_GPU_MATRIX_URL)
+    tables = pandas.read_html(response.content)
+    (
+        nvenc_recent, nvenc_consumer, nvenc_workstation, nvenc_virt,
+        nvdec_recent, nvdec_consumer, nvdec_workstation, nvdec_virt) = tables
+    nvidia = dict(lines=[], model_lines={}, boards={})
+
+    # Compile aggregate data needed to parse individual rows
+    for nvenc_table in (
+            nvenc_recent, nvenc_consumer, nvenc_workstation, nvenc_virt):
+        for board in nvenc_table['BOARD']:
+            line = board.replace('\xa0', ' ').split(None, 1)[0].lower()
+            if line not in nvidia['lines']:
+                nvidia['lines'].append(line)
+    for line, line_suffixes in NVIDIA_LINE_SUFFIXES.items():
+        for line_suffix in reversed(line_suffixes):
+            nvidia['lines'].insert(0, ' '.join((line, line_suffix)))
+
+    for nvenc_table in (
+            nvenc_recent, nvenc_consumer, nvenc_workstation, nvenc_virt):
+        for nvenc_row_idx, nvenc_row in nvenc_table.iterrows():
+            nvenc_row_values = {
+                idx: cell for idx, cell in enumerate(nvenc_row[1:]) if (
+                    cell and
+                    not (isinstance(cell, float) and math.isnan(cell)))}
+            if not nvenc_row_values:
+                # Divider row
+                continue
+
+            # Assemble the data for this row to use for each model or range
+            model_data = {}
+            for key, value in nvenc_row.items():
+                if value in {'YES', 'NO'}:
+                    model_data[key] = value == 'YES'
+                else:
+                    model_data[key] = value
+            model_data['BOARD'] = model_data['BOARD'].replace(
+                '\xa0', ' ')
+            # Add keys for the data for the ffmpeg codec names for fast lookup
+            for codec_prefix, codec in NVIDIA_CODEC_COLUMN_PREFIXES.items():
+                for column_idx, column in enumerate(nvenc_row.keys()):
+                    if column.lower().startswith(codec_prefix):
+                        model_data[codec] = nvenc_row[column_idx] == 'YES'
+                        break
+            nvidia['boards'][model_data['BOARD']] = model_data
+
+            _detect._parse_models(
+                model_lines=nvidia['lines'],
+                boards=model_data['BOARD'].lower(),
+                model_data=model_data['BOARD'],
+                model_lines_data=nvidia['model_lines'])
+
+    # Clean up some annoying clashes between the titan model line and GeForce
+    # GTX model numbers
+    for model_line, model_line_suffixes in NVIDIA_LINE_SUFFIXES.items():
+        models_data = nvidia['model_lines'][model_line]['models']
+        for model_num in models_data:
+            for model_line_suffix in model_line_suffixes:
+                if model_num.startswith(model_line_suffix + ' '):
+                    models_data[model_num[
+                        len(model_line_suffix + ' '):]] = models_data.pop(
+                            model_num)
+    for titan_model_num in {'black', 'xp'}:
+        nvidia['model_lines']['geforce gtx']['models'][
+            'titan ' + titan_model_num] = nvidia['model_lines'][
+                'titan']['models'].pop(titan_model_num)
+    for titan_model_num in list(nvidia['model_lines'][
+            'geforce gtx titan']['models'].keys()):
+        nvidia['model_lines']['geforce gtx']['models'][
+            'titan ' + titan_model_num] = nvidia['model_lines'][
+                'geforce gtx titan']['models'].pop(titan_model_num)
+    nvidia['model_lines']['geforce gtx']['models']['titan'] = nvidia[
+        'model_lines']['geforce gtx']['models']['titan black']
+    del nvidia['model_lines']['geforce gtx']['models']['titan ']
+    del nvidia['model_lines']['geforce gtx titan']
+
+    return nvidia
+
+
 def main():
     """
     Download ffmpeg detection data.
     """
-    data = dict(hwaccels=get_hwaccel_data())
+    data = dict(
+        hwaccels=get_hwaccel_data(),
+        nvidia=get_nvidia_data(),
+    )
     json.dump(data, sys.stdout, indent=2)
 
 
diff --git a/ffmpeg/_detect.py b/ffmpeg/_detect.py
index bf22797c..df1bbcf5 100644
--- a/ffmpeg/_detect.py
+++ b/ffmpeg/_detect.py
@@ -275,9 +275,13 @@ def _parse_models(
                     model_range_separator)
                 if len(model_range_parameters) > 1:
                     # This is a range of models
-                    model_line_data['model_ranges'].append(
-                        [model_range, model_data])
-                    models.remove(model_range)
+                    if model_range in model_line_data['model_ranges']:
+                        model_line_data['model_ranges'][
+                            model_line_data['model_ranges'].index(
+                                model_range)] = model_data
+                    else:
+                        model_line_data['model_ranges'].append(
+                            [model_range, model_data])
                     break
             else:
                 model_line_data['models'][model_range] = model_data
diff --git a/ffmpeg/detect.json b/ffmpeg/detect.json
index 19102f7a..68736e09 100644
--- a/ffmpeg/detect.json
+++ b/ffmpeg/detect.json
@@ -8,39 +8,16 @@
           "vaapi",
           "vdpau"
         ],
-        "NVIDIA": [
-          "cuvid",
-          "opencl",
-          "vaapi",
-          "vdpau"
-        ],
         "Intel": [
           "libmfx",
           "opencl",
           "vaapi"
-        ]
-      },
-      "Darwin": {
-        "iOS": [
-          "videotoolbox"
         ],
-        "macOS": [
-          "opencl",
-          "videotoolbox"
-        ]
-      },
-      "Android": {
-        "NaN": [
-          "mediacodec",
+        "NVIDIA": [
+          "cuvid",
           "opencl",
-          "omx",
-          "v4l2m2m"
-        ]
-      },
-      "Other": {
-        "Raspberry Pi": [
-          "mmal",
-          "omx"
+          "vaapi",
+          "vdpau"
         ]
       },
       "Windows": {
@@ -51,20 +28,2202 @@
           "mediafoundation",
           "opencl"
         ],
-        "NVIDIA": [
-          "cuvid",
+        "Intel": [
           "d3d11va",
           "dxva2",
+          "libmfx",
           "mediafoundation",
           "opencl"
         ],
-        "Intel": [
+        "NVIDIA": [
+          "cuvid",
           "d3d11va",
           "dxva2",
-          "libmfx",
           "mediafoundation",
           "opencl"
         ]
+      },
+      "Android": {
+        "NaN": [
+          "mediacodec",
+          "opencl",
+          "omx",
+          "v4l2m2m"
+        ]
+      },
+      "Darwin": {
+        "macOS": [
+          "opencl",
+          "videotoolbox"
+        ],
+        "iOS": [
+          "videotoolbox"
+        ]
+      },
+      "Other": {
+        "Raspberry Pi": [
+          "mmal",
+          "omx"
+        ]
+      }
+    }
+  },
+  "nvidia": {
+    "lines": [
+      "geforce gtx titan",
+      "geforce gtx",
+      "geforce gt",
+      "geforce rtx",
+      "geforce",
+      "titan",
+      "quadro",
+      "tesla",
+      "grid"
+    ],
+    "model_lines": {
+      "geforce gt": {
+        "models": {
+          "1030": "GeForce GT 1030",
+          "723a": "GeForce GT 723A / 740A",
+          "740a": "GeForce GT 723A / 740A",
+          "630": "GeForce GT 630 / 635/ 640 / 710 / 730",
+          "635": "GeForce GT 630 / 635/ 640 / 710 / 730",
+          "640": "GeForce GT 630 / 635/ 640 / 710 / 730",
+          "710": "GeForce GT 630 / 635/ 640 / 710 / 730",
+          "730": "GeForce GT 630 / 635/ 640 / 710 / 730",
+          "740": "GeForce GTX 645 -660 Ti Boost GeForce GT 740"
+        },
+        "model_ranges": [
+          [
+            "720m > 740m",
+            "GeForce GT 720M > 740M"
+          ],
+          [
+            "630 > 640",
+            "GeForce GT 630 > 640 GeForce GTX 650 GeForce GT 740"
+          ],
+          [
+            "780 - 780 ti",
+            "GeForce GT 780 - 780 Ti"
+          ]
+        ]
+      },
+      "geforce gtx": {
+        "models": {
+          "1050": "GeForce GTX 1050 / 1050 Ti",
+          "1050 ti": "GeForce GTX 1050 / 1050 Ti",
+          "1060": "GeForce GTX 1060",
+          "1070m": "GeForce GTX 1070M / 1080M",
+          "1080m": "GeForce GTX 1070M / 1080M",
+          "1070": "GeForce GTX 1070 / 1070Ti",
+          "1070ti": "GeForce GTX 1070 / 1070Ti",
+          "1080": "GeForce GTX 1080",
+          "1080 ti": "GeForce GTX 1080 Ti",
+          "1650": "GeForce GTX 1650",
+          "1660 ti": "GeForce GTX 1660 Ti / 1660",
+          "1660": "GeForce GTX 1660 Ti / 1660",
+          "650": "GeForce GT 630 > 640 GeForce GTX 650 GeForce GT 740",
+          "750": "GeForce GTX 750 GeForce GTX 950 - 960",
+          "965m": "GeForce GTX 965M",
+          "910m": "GeForce GTX 910M / 920M / 920A",
+          "920m": "GeForce GTX 910M / 920M / 920A",
+          "920a": "GeForce GTX 910M / 920M / 920A",
+          "980mx": "GeForce GTX 965M > 980M / 980MX",
+          "980 ti": "GeForce GTX 980 Ti",
+          "titan xp": "GeForce GTX Titan X / Titan Xp",
+          "titan black": "GeForce GTX Titan / Titan Black",
+          "titan x": "GeForce GTX Titan X / Titan Xp",
+          "titan z": "GeForce GTX Titan Z",
+          "titan": "GeForce GTX Titan / Titan Black"
+        },
+        "model_ranges": [
+          [
+            "645 -660 ti boost",
+            "GeForce GTX 645 -660 Ti Boost GeForce GT 740"
+          ],
+          [
+            "660 - 690",
+            "GeForce GTX 660 - 690 GeForce GTX 760 - 770"
+          ],
+          [
+            "760 - 770",
+            "GeForce GTX 660 - 690 GeForce GTX 760 - 770"
+          ],
+          [
+            "745 - 750 ti",
+            "GeForce GTX 745 - 750 Ti"
+          ],
+          [
+            "850a > 960a",
+            "GeForce GTX 850A > 960A"
+          ],
+          [
+            "850m > 960m",
+            "GeForce GTX 850M > 960M"
+          ],
+          [
+            "920mx - 940mx",
+            "GeForce GTX 920MX - 940MX"
+          ],
+          [
+            "950 - 960",
+            "GeForce GTX 750 GeForce GTX 950 - 960"
+          ],
+          [
+            "965m > 980m",
+            "GeForce GTX 965M > 980M / 980MX"
+          ],
+          [
+            "960 ti - 980",
+            "GeForce GTX 960 Ti - 980"
+          ]
+        ]
+      },
+      "titan": {
+        "models": {
+          "v": "Titan V",
+          "rtx": "Titan RTX"
+        },
+        "model_ranges": []
+      },
+      "geforce rtx": {
+        "models": {
+          "2060": "GeForce RTX 2060 / 2070",
+          "2070": "GeForce RTX 2060 / 2070",
+          "2080": "GeForce RTX 2080",
+          "2080 ti": "GeForce RTX 2080 Ti"
+        },
+        "model_ranges": []
+      },
+      "quadro": {
+        "models": {
+          "p500": "Quadro P500 / P520",
+          "p520": "Quadro P500 / P520",
+          "p400": "Quadro P400",
+          "p600": "Quadro P600 / P1000",
+          "p1000": "Quadro P600 / P1000",
+          "p2000": "Quadro P2000 / P2200",
+          "p2200": "Quadro P2000 / P2200",
+          "p3200": "Quadro P3200 / P4200 / P5200",
+          "p4200": "Quadro P3200 / P4200 / P5200",
+          "p5200": "Quadro P3200 / P4200 / P5200",
+          "p4000": "Quadro P4000",
+          "p5000": "Quadro P5000",
+          "p6000": "Quadro P6000",
+          "gp100": "Quadro GP100",
+          "gv100": "Quadro GV100",
+          "t1000": "Quadro T1000",
+          "t2000": "Quadro T2000",
+          "rtx 3000": "Quadro RTX 3000",
+          "rtx 5000": "Quadro RTX 5000/RTX 4000",
+          "rtx 4000": "Quadro RTX 5000/RTX 4000",
+          "rtx 6000": "Quadro RTX 6000/RTX 8000",
+          "rtx 8000": "Quadro RTX 6000/RTX 8000",
+          "k420": "Quadro K420 / K600",
+          "k600": "Quadro K420 / K600",
+          "k2000": "Quadro K2000 / K2000D",
+          "k2000d": "Quadro K2000 / K2000D",
+          "k4000": "Quadro K4000",
+          "k5100": "Quadro K100 > K2000 + K5100",
+          "k4200": "Quadro K4200 / K5000",
+          "k5000": "Quadro K4200 / K5000",
+          "k5200": "Quadro K5200 / K6000",
+          "k6000": "Quadro K5200 / K6000",
+          "k620": "Quadro K620 / K1200",
+          "k1200": "Quadro K620 / K1200",
+          "k2200": "Quadro K2200",
+          "m500": "Quadro M500 / M520",
+          "m520": "Quadro M500 / M520",
+          "m600": "Quadro M600 / M620",
+          "m620": "Quadro M600 / M620",
+          "m1000": "Quadro M1000 / M1200 / M2000",
+          "m1200": "Quadro M1000 / M1200 / M2000",
+          "m2000": "Quadro M2000",
+          "m2200": "Quadro M2200",
+          "m3000": "Quadro M3000 / M4000 / M5500",
+          "m4000": "Quadro M4000 / M5000",
+          "m5500": "Quadro M3000 / M4000 / M5500",
+          "m5000": "Quadro M4000 / M5000",
+          "m6000": "Quadro M6000"
+        },
+        "model_ranges": [
+          [
+            "k2100 > k5000",
+            "Quadro K2100 > K5000"
+          ],
+          [
+            "k100 > k2000",
+            "Quadro K100 > K2000 + K5100"
+          ]
+        ]
+      },
+      "tesla": {
+        "models": {
+          "p4": "Tesla P4",
+          "p6": "Tesla P6",
+          "p40": "Tesla P40",
+          "p100": "Tesla P100",
+          "v100": "Tesla V100",
+          "t4": "Tesla T4",
+          "k10": "Tesla K10",
+          "k20x": "Tesla K20X",
+          "k40": "Tesla K40",
+          "k80": "Tesla K80",
+          "m10": "Tesla M10",
+          "m4": "Tesla M4",
+          "m40": "Tesla M40",
+          "m6": "Tesla M6",
+          "m60": "Tesla M60"
+        },
+        "model_ranges": []
+      },
+      "geforce": {
+        "models": {
+          "710a": "GeForce 710A / 810M / 820M",
+          "810m": "GeForce 710A / 810M / 820M",
+          "820m": "GeForce 710A / 810M / 820M",
+          "845m": "GeForce 845M / 940M / 940MX / 945M",
+          "940m": "GeForce 845M / 940M / 940MX / 945M",
+          "940mx": "GeForce 845M / 940M / 940MX / 945M",
+          "945m": "GeForce 845M / 940M / 940MX / 945M",
+          "mx110": "GeForce MX110 / MX130",
+          "mx130": "GeForce MX110 / MX130",
+          "660m": "GeForce 640M > GT 755M / GTX 660M"
+        },
+        "model_ranges": [
+          [
+            "710a > 810a",
+            "GeForce 710A > 810A"
+          ],
+          [
+            "640m > gt 755m",
+            "GeForce 640M > GT 755M / GTX 660M"
+          ],
+          [
+            "830a > 945a",
+            "GeForce 830A > 945A"
+          ],
+          [
+            "830m > 945m",
+            "GeForce 830M > 945M"
+          ],
+          [
+            "mx150 > mx250",
+            "GeForce MX150 > MX250"
+          ]
+        ]
+      },
+      "grid": {
+        "models": {
+          "k1": "GRID K1",
+          "k2": "GRID K2",
+          "k340": "GRID K340",
+          "k520": "GRID K520"
+        },
+        "model_ranges": []
+      }
+    },
+    "boards": {
+      "GeForce GT 1030": {
+        "BOARD": "GeForce GT 1030",
+        "FAMILY": "Pascal",
+        "CHIP": "GP108",
+        "Desktop/Mobile/Server": "D",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": "0",
+        "Total # of NVENC": "0",
+        "Max # of concurrent sessions": 0.0,
+        "H.264 (AVCHD) YUV 4:2:0": false,
+        "H.264 (AVCHD) YUV 4:4:4": false,
+        "H.264 (AVCHD) Lossless": false,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": false,
+        "hevc": false
+      },
+      "GeForce GTX 1050 / 1050 Ti": {
+        "BOARD": "GeForce GTX 1050 / 1050 Ti",
+        "FAMILY": "Pascal",
+        "CHIP": "GP106",
+        "Desktop/Mobile/Server": "D/M",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": "1",
+        "Total # of NVENC": "1",
+        "Max # of concurrent sessions": 2.0,
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": true,
+        "H.265 (HEVC) 4K Lossless": true,
+        "H.265 (HEVC) 8k": true,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": true
+      },
+      "GeForce GTX 1060": {
+        "BOARD": "GeForce GTX 1060",
+        "FAMILY": "Pascal",
+        "CHIP": "GP104",
+        "Desktop/Mobile/Server": "D/M",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": "1",
+        "Total # of NVENC": "1",
+        "Max # of concurrent sessions": 2.0,
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": true,
+        "H.265 (HEVC) 4K Lossless": true,
+        "H.265 (HEVC) 8k": true,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": true
+      },
+      "GeForce GTX 1070M / 1080M": {
+        "BOARD": "GeForce GTX 1070M / 1080M",
+        "FAMILY": "Pascal",
+        "CHIP": "GP104B",
+        "Desktop/Mobile/Server": "M",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": "2",
+        "Total # of NVENC": "2",
+        "Max # of concurrent sessions": 2.0,
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": true,
+        "H.265 (HEVC) 4K Lossless": true,
+        "H.265 (HEVC) 8k": true,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": true
+      },
+      "GeForce GTX 1070 / 1070Ti": {
+        "BOARD": "GeForce GTX 1070 / 1070Ti",
+        "FAMILY": "Pascal",
+        "CHIP": "GP104",
+        "Desktop/Mobile/Server": "D/M",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": "2",
+        "Total # of NVENC": "2",
+        "Max # of concurrent sessions": 2.0,
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": true,
+        "H.265 (HEVC) 4K Lossless": true,
+        "H.265 (HEVC) 8k": true,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": true
+      },
+      "GeForce GTX 1080": {
+        "BOARD": "GeForce GTX 1080",
+        "FAMILY": "Pascal",
+        "CHIP": "GP104",
+        "Desktop/Mobile/Server": "D/M",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": "2",
+        "Total # of NVENC": "2",
+        "Max # of concurrent sessions": 2.0,
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": true,
+        "H.265 (HEVC) 4K Lossless": true,
+        "H.265 (HEVC) 8k": true,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": true
+      },
+      "GeForce GTX 1080 Ti": {
+        "BOARD": "GeForce GTX 1080 Ti",
+        "FAMILY": "Pascal",
+        "CHIP": "GP102",
+        "Desktop/Mobile/Server": "D",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": "2",
+        "Total # of NVENC": "2",
+        "Max # of concurrent sessions": 2.0,
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": true,
+        "H.265 (HEVC) 4K Lossless": true,
+        "H.265 (HEVC) 8k": true,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": true
+      },
+      "GeForce GTX Titan X / Titan Xp": {
+        "BOARD": "GeForce GTX Titan X / Titan Xp",
+        "FAMILY": "Pascal",
+        "CHIP": "GP102",
+        "Desktop/Mobile/Server": "D",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": "2",
+        "Total # of NVENC": "2",
+        "Max # of concurrent sessions": 2.0,
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": true,
+        "H.265 (HEVC) 4K Lossless": true,
+        "H.265 (HEVC) 8k": true,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": true
+      },
+      "Titan V": {
+        "BOARD": "Titan V",
+        "FAMILY": "Volta",
+        "CHIP": "GV100",
+        "Desktop/Mobile/Server": "D",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": "3",
+        "Total # of NVENC": "3",
+        "Max # of concurrent sessions": 2.0,
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": true,
+        "H.265 (HEVC) 4K Lossless": true,
+        "H.265 (HEVC) 8k": true,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": true
+      },
+      "GeForce GTX 1650": {
+        "BOARD": "GeForce GTX 1650",
+        "FAMILY": "Turing*",
+        "CHIP": "TU117",
+        "Desktop/Mobile/Server": "D/M",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": "1*",
+        "Total # of NVENC": "1*",
+        "Max # of concurrent sessions": 2.0,
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": true,
+        "H.265 (HEVC) 4K Lossless": true,
+        "H.265 (HEVC) 8k": true,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": true
+      },
+      "GeForce GTX 1660 Ti / 1660": {
+        "BOARD": "GeForce GTX 1660 Ti / 1660",
+        "FAMILY": "Turing",
+        "CHIP": "TU116",
+        "Desktop/Mobile/Server": "D/M",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": "1",
+        "Total # of NVENC": "1",
+        "Max # of concurrent sessions": 2.0,
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": true,
+        "H.265 (HEVC) 4K Lossless": true,
+        "H.265 (HEVC) 8k": true,
+        "HEVC B Frame support": true,
+        "h264": true,
+        "hevc": true
+      },
+      "GeForce RTX 2060 / 2070": {
+        "BOARD": "GeForce RTX 2060 / 2070",
+        "FAMILY": "Turing",
+        "CHIP": "TU106",
+        "Desktop/Mobile/Server": "D/M",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": "1",
+        "Total # of NVENC": "1",
+        "Max # of concurrent sessions": 2.0,
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": true,
+        "H.265 (HEVC) 4K Lossless": true,
+        "H.265 (HEVC) 8k": true,
+        "HEVC B Frame support": true,
+        "h264": true,
+        "hevc": true
+      },
+      "GeForce RTX 2080": {
+        "BOARD": "GeForce RTX 2080",
+        "FAMILY": "Turing",
+        "CHIP": "TU104",
+        "Desktop/Mobile/Server": "D/M",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": "1",
+        "Total # of NVENC": "1",
+        "Max # of concurrent sessions": 2.0,
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": true,
+        "H.265 (HEVC) 4K Lossless": true,
+        "H.265 (HEVC) 8k": true,
+        "HEVC B Frame support": true,
+        "h264": true,
+        "hevc": true
+      },
+      "GeForce RTX 2080 Ti": {
+        "BOARD": "GeForce RTX 2080 Ti",
+        "FAMILY": "Turing",
+        "CHIP": "TU102",
+        "Desktop/Mobile/Server": "D",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": "1",
+        "Total # of NVENC": "1",
+        "Max # of concurrent sessions": 2.0,
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": true,
+        "H.265 (HEVC) 4K Lossless": true,
+        "H.265 (HEVC) 8k": true,
+        "HEVC B Frame support": true,
+        "h264": true,
+        "hevc": true
+      },
+      "Titan RTX": {
+        "BOARD": "Titan RTX",
+        "FAMILY": "Turing",
+        "CHIP": "TU102",
+        "Desktop/Mobile/Server": "D",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": "1",
+        "Total # of NVENC": "1",
+        "Max # of concurrent sessions": 2.0,
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": true,
+        "H.265 (HEVC) 4K Lossless": true,
+        "H.265 (HEVC) 8k": true,
+        "HEVC B Frame support": true,
+        "h264": true,
+        "hevc": true
+      },
+      "Quadro P500 / P520": {
+        "BOARD": "Quadro P500 / P520",
+        "FAMILY": "Pascal",
+        "CHIP": "GP108",
+        "Desktop/Mobile/Server": "M",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": 0,
+        "Total # of NVENC": 0,
+        "Max # of concurrent sessions": "0",
+        "H.264 (AVCHD) YUV 4:2:0": false,
+        "H.264 (AVCHD) YUV 4:4:4": false,
+        "H.264 (AVCHD) Lossless": false,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": false,
+        "hevc": false
+      },
+      "Quadro P400": {
+        "BOARD": "Quadro P400",
+        "FAMILY": "Pascal",
+        "CHIP": "GP107",
+        "Desktop/Mobile/Server": "D",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": 1,
+        "Total # of NVENC": 1,
+        "Max # of concurrent sessions": "2",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": true,
+        "H.265 (HEVC) 4K Lossless": true,
+        "H.265 (HEVC) 8k": true,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": true
+      },
+      "Quadro P600 / P1000": {
+        "BOARD": "Quadro P600 / P1000",
+        "FAMILY": "Pascal",
+        "CHIP": "GP107",
+        "Desktop/Mobile/Server": "D/M",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": 1,
+        "Total # of NVENC": 1,
+        "Max # of concurrent sessions": "2",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": true,
+        "H.265 (HEVC) 4K Lossless": true,
+        "H.265 (HEVC) 8k": true,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": true
+      },
+      "Quadro P2000": {
+        "BOARD": "Quadro P2000",
+        "FAMILY": "Pascal",
+        "CHIP": "GP107",
+        "Desktop/Mobile/Server": "M",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": 1,
+        "Total # of NVENC": 1,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": true,
+        "H.265 (HEVC) 4K Lossless": true,
+        "H.265 (HEVC) 8k": true,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": true
+      },
+      "Quadro P2000 / P2200": {
+        "BOARD": "Quadro P2000 / P2200",
+        "FAMILY": "Pascal",
+        "CHIP": "GP106",
+        "Desktop/Mobile/Server": "D",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": 1,
+        "Total # of NVENC": 1,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": true,
+        "H.265 (HEVC) 4K Lossless": true,
+        "H.265 (HEVC) 8k": true,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": true
+      },
+      "Quadro P3200 / P4200 / P5200": {
+        "BOARD": "Quadro P3200 / P4200 / P5200",
+        "FAMILY": "Pascal",
+        "CHIP": "GP104",
+        "Desktop/Mobile/Server": "M",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": 2,
+        "Total # of NVENC": 2,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": true,
+        "H.265 (HEVC) 4K Lossless": true,
+        "H.265 (HEVC) 8k": true,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": true
+      },
+      "Quadro P4000": {
+        "BOARD": "Quadro P4000",
+        "FAMILY": "Pascal",
+        "CHIP": "GP104",
+        "Desktop/Mobile/Server": "D",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": 1,
+        "Total # of NVENC": 1,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": true,
+        "H.265 (HEVC) 4K Lossless": true,
+        "H.265 (HEVC) 8k": true,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": true
+      },
+      "Quadro P5000": {
+        "BOARD": "Quadro P5000",
+        "FAMILY": "Pascal",
+        "CHIP": "GP104",
+        "Desktop/Mobile/Server": "D",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": 2,
+        "Total # of NVENC": 2,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": true,
+        "H.265 (HEVC) 4K Lossless": true,
+        "H.265 (HEVC) 8k": true,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": true
+      },
+      "Quadro P6000": {
+        "BOARD": "Quadro P6000",
+        "FAMILY": "Pascal",
+        "CHIP": "GP102",
+        "Desktop/Mobile/Server": "D",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": 2,
+        "Total # of NVENC": 2,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": true,
+        "H.265 (HEVC) 4K Lossless": true,
+        "H.265 (HEVC) 8k": true,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": true
+      },
+      "Quadro GP100": {
+        "BOARD": "Quadro GP100",
+        "FAMILY": "Pascal",
+        "CHIP": "GP100",
+        "Desktop/Mobile/Server": "D",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": 3,
+        "Total # of NVENC": 3,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": true,
+        "H.265 (HEVC) 4K Lossless": true,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": true
+      },
+      "Quadro GV100": {
+        "BOARD": "Quadro GV100",
+        "FAMILY": "Volta",
+        "CHIP": "GV100",
+        "Desktop/Mobile/Server": "D",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": 3,
+        "Total # of NVENC": 3,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": true,
+        "H.265 (HEVC) 4K Lossless": true,
+        "H.265 (HEVC) 8k": true,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": true
+      },
+      "Quadro T1000": {
+        "BOARD": "Quadro T1000",
+        "FAMILY": "Turing",
+        "CHIP": "TU117",
+        "Desktop/Mobile/Server": "M",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": 1,
+        "Total # of NVENC": 1,
+        "Max # of concurrent sessions": "2",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": true,
+        "H.265 (HEVC) 4K Lossless": true,
+        "H.265 (HEVC) 8k": true,
+        "HEVC B Frame support": true,
+        "h264": true,
+        "hevc": true
+      },
+      "Quadro T2000": {
+        "BOARD": "Quadro T2000",
+        "FAMILY": "Turing",
+        "CHIP": "TU117",
+        "Desktop/Mobile/Server": "M",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": 1,
+        "Total # of NVENC": 1,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": true,
+        "H.265 (HEVC) 4K Lossless": true,
+        "H.265 (HEVC) 8k": true,
+        "HEVC B Frame support": true,
+        "h264": true,
+        "hevc": true
+      },
+      "Quadro RTX 3000": {
+        "BOARD": "Quadro RTX 3000",
+        "FAMILY": "Turing",
+        "CHIP": "TU106",
+        "Desktop/Mobile/Server": "M",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": 1,
+        "Total # of NVENC": 1,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": true,
+        "H.265 (HEVC) 4K Lossless": true,
+        "H.265 (HEVC) 8k": true,
+        "HEVC B Frame support": true,
+        "h264": true,
+        "hevc": true
+      },
+      "Quadro RTX 5000/RTX 4000": {
+        "BOARD": "Quadro RTX 5000/RTX 4000",
+        "FAMILY": "Turing",
+        "CHIP": "TU104",
+        "Desktop/Mobile/Server": "D/M",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": 1,
+        "Total # of NVENC": 1,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": true,
+        "H.265 (HEVC) 4K Lossless": true,
+        "H.265 (HEVC) 8k": true,
+        "HEVC B Frame support": true,
+        "h264": true,
+        "hevc": true
+      },
+      "Quadro RTX 6000/RTX 8000": {
+        "BOARD": "Quadro RTX 6000/RTX 8000",
+        "FAMILY": "Turing",
+        "CHIP": "TU102",
+        "Desktop/Mobile/Server": "D",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": 1,
+        "Total # of NVENC": 1,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": true,
+        "H.265 (HEVC) 4K Lossless": true,
+        "H.265 (HEVC) 8k": true,
+        "HEVC B Frame support": true,
+        "h264": true,
+        "hevc": true
+      },
+      "Tesla P4 / P6": {
+        "BOARD": "Tesla P4 / P6",
+        "FAMILY": "Pascal",
+        "CHIP": "GP104",
+        "Desktop/Mobile/Server": "S",
+        "# OF CHIPS": 1.0,
+        "# OF NVENC/CHIP": "2",
+        "Total # of NVENC": "2",
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": true,
+        "H.265 (HEVC) 4K Lossless": true,
+        "H.265 (HEVC) 8k": true,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": true
+      },
+      "Tesla P40": {
+        "BOARD": "Tesla P40",
+        "FAMILY": "Pascal",
+        "CHIP": "GP102",
+        "# OF CHIPS": 1.0,
+        "# OF NVENC/CHIP": 2.0,
+        "Total # of NVENC": 2.0,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": true,
+        "H.265 (HEVC) 4K Lossless": true,
+        "H.265 (HEVC) 8k": true,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": true
+      },
+      "Tesla P100": {
+        "BOARD": "Tesla P100",
+        "FAMILY": "Pascal",
+        "CHIP": "GP100",
+        "# OF CHIPS": 1.0,
+        "# OF NVENC/CHIP": 3.0,
+        "Total # of NVENC": 3.0,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": true,
+        "H.265 (HEVC) 4K Lossless": true,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": true
+      },
+      "Tesla V100": {
+        "BOARD": "Tesla V100",
+        "FAMILY": "Volta",
+        "CHIP": "GV100",
+        "# OF CHIPS": 1.0,
+        "# OF NVENC/CHIP": 3.0,
+        "Total # of NVENC": 3.0,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": true,
+        "H.265 (HEVC) 4K Lossless": true,
+        "H.265 (HEVC) 8k": true,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": true
+      },
+      "Tesla T4": {
+        "BOARD": "Tesla T4",
+        "FAMILY": "Turing",
+        "CHIP": "TU104",
+        "# OF CHIPS": 1.0,
+        "# OF NVENC/CHIP": 1.0,
+        "Total # of NVENC": 1.0,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": true,
+        "H.265 (HEVC) 4K Lossless": true,
+        "H.265 (HEVC) 8k": true,
+        "HEVC B Frame support": true,
+        "h264": true,
+        "hevc": true
+      },
+      "GeForce 710A > 810A": {
+        "BOARD": "GeForce 710A > 810A",
+        "FAMILY": "Kepler",
+        "CHIP": "GK208",
+        "Desktop/Mobile/Server": "M",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": "1",
+        "Total # of NVENC": "1",
+        "Max # of concurrent sessions": 2.0,
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": false,
+        "H.264 (AVCHD) Lossless": false,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": false
+      },
+      "GeForce GT 723A / 740A": {
+        "BOARD": "GeForce GT 723A / 740A",
+        "FAMILY": "Kepler",
+        "CHIP": "GK208",
+        "Desktop/Mobile/Server": "M",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": "1",
+        "Total # of NVENC": "1",
+        "Max # of concurrent sessions": 2.0,
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": false,
+        "H.264 (AVCHD) Lossless": false,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": false
+      },
+      "GeForce GT 720M > 740M": {
+        "BOARD": "GeForce GT 720M > 740M",
+        "FAMILY": "Kepler",
+        "CHIP": "GK208",
+        "Desktop/Mobile/Server": "M",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": "1",
+        "Total # of NVENC": "1",
+        "Max # of concurrent sessions": 2.0,
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": false,
+        "H.264 (AVCHD) Lossless": false,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": false
+      },
+      "GeForce GT 630 / 635/ 640 / 710 / 730": {
+        "BOARD": "GeForce GT 630 / 635/ 640 / 710 / 730",
+        "FAMILY": "Kepler",
+        "CHIP": "GK208",
+        "Desktop/Mobile/Server": "D",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": "1",
+        "Total # of NVENC": "1",
+        "Max # of concurrent sessions": 2.0,
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": false,
+        "H.264 (AVCHD) Lossless": false,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": false
+      },
+      "GeForce 710A / 810M / 820M": {
+        "BOARD": "GeForce 710A / 810M / 820M",
+        "FAMILY": "Kepler",
+        "CHIP": "GK107",
+        "Desktop/Mobile/Server": "M",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": "1",
+        "Total # of NVENC": "1",
+        "Max # of concurrent sessions": 2.0,
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": false,
+        "H.264 (AVCHD) Lossless": false,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": false
+      },
+      "GeForce 640M > GT 755M / GTX 660M": {
+        "BOARD": "GeForce 640M > GT 755M / GTX 660M",
+        "FAMILY": "Kepler",
+        "CHIP": "GK107",
+        "Desktop/Mobile/Server": "M",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": "1",
+        "Total # of NVENC": "1",
+        "Max # of concurrent sessions": 2.0,
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": false,
+        "H.264 (AVCHD) Lossless": false,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": false
+      },
+      "GeForce GT 630 > 640 GeForce GTX 650 GeForce GT 740": {
+        "BOARD": "GeForce GT 630 > 640 GeForce GTX 650 GeForce GT 740",
+        "FAMILY": "Kepler",
+        "CHIP": "GK107",
+        "Desktop/Mobile/Server": "D",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": "1",
+        "Total # of NVENC": "1",
+        "Max # of concurrent sessions": 2.0,
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": false,
+        "H.264 (AVCHD) Lossless": false,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": false
+      },
+      "GeForce GTX 645 -660 Ti Boost GeForce GT 740": {
+        "BOARD": "GeForce GTX 645 -660 Ti Boost GeForce GT 740",
+        "FAMILY": "Kepler",
+        "CHIP": "GK106",
+        "Desktop/Mobile/Server": "D",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": "1",
+        "Total # of NVENC": "1",
+        "Max # of concurrent sessions": 2.0,
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": false,
+        "H.264 (AVCHD) Lossless": false,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": false
+      },
+      "GeForce GTX 660 - 690 GeForce GTX 760 - 770": {
+        "BOARD": "GeForce GTX 660 - 690 GeForce GTX 760 - 770",
+        "FAMILY": "Kepler",
+        "CHIP": "GK104",
+        "Desktop/Mobile/Server": "D",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": "1",
+        "Total # of NVENC": "1",
+        "Max # of concurrent sessions": 2.0,
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": false,
+        "H.264 (AVCHD) Lossless": false,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": false
+      },
+      "GeForce GT 780 - 780 Ti": {
+        "BOARD": "GeForce GT 780 - 780 Ti",
+        "FAMILY": "Kepler\u00a0(2nd\u00a0Gen)",
+        "CHIP": "GK110",
+        "Desktop/Mobile/Server": "D",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": "1",
+        "Total # of NVENC": "1",
+        "Max # of concurrent sessions": 2.0,
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": false,
+        "H.264 (AVCHD) Lossless": false,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": false
+      },
+      "GeForce GTX Titan / Titan Black": {
+        "BOARD": "GeForce GTX Titan / Titan Black",
+        "FAMILY": "Kepler\u00a0(2nd\u00a0Gen)",
+        "CHIP": "GK110",
+        "Desktop/Mobile/Server": "D",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": "1",
+        "Total # of NVENC": "1",
+        "Max # of concurrent sessions": 2.0,
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": false,
+        "H.264 (AVCHD) Lossless": false,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": false
+      },
+      "GeForce GTX Titan Z": {
+        "BOARD": "GeForce GTX Titan Z",
+        "FAMILY": "Kepler\u00a0(2nd\u00a0Gen)",
+        "CHIP": "GK110",
+        "Desktop/Mobile/Server": "D",
+        "# OF CHIPS": 2,
+        "# OF NVENC/CHIP": "1",
+        "Total # of NVENC": "2",
+        "Max # of concurrent sessions": 2.0,
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": false,
+        "H.264 (AVCHD) Lossless": false,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": false
+      },
+      "GeForce GTX 745 - 750 Ti": {
+        "BOARD": "GeForce GTX 745 - 750 Ti",
+        "FAMILY": "Maxwell\u00a0(1st\u00a0Gen)",
+        "CHIP": "GM107",
+        "Desktop/Mobile/Server": "D",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": "1",
+        "Total # of NVENC": "1",
+        "Max # of concurrent sessions": 2.0,
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": false
+      },
+      "GeForce 845M / 940M / 940MX / 945M": {
+        "BOARD": "GeForce 845M / 940M / 940MX / 945M",
+        "FAMILY": "Maxwell\u00a0(1st\u00a0Gen)",
+        "CHIP": "GM107",
+        "Desktop/Mobile/Server": "M",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": "1",
+        "Total # of NVENC": "1",
+        "Max # of concurrent sessions": 2.0,
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": false
+      },
+      "GeForce GTX 850A > 960A": {
+        "BOARD": "GeForce GTX 850A > 960A",
+        "FAMILY": "Maxwell\u00a0(1st\u00a0Gen)",
+        "CHIP": "GM107",
+        "Desktop/Mobile/Server": "M",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": "1",
+        "Total # of NVENC": "1",
+        "Max # of concurrent sessions": 2.0,
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": false
+      },
+      "GeForce GTX 850M > 960M": {
+        "BOARD": "GeForce GTX 850M > 960M",
+        "FAMILY": "Maxwell\u00a0(1st\u00a0Gen)",
+        "CHIP": "GM107",
+        "Desktop/Mobile/Server": "M",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": "1",
+        "Total # of NVENC": "1",
+        "Max # of concurrent sessions": 2.0,
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": false
+      },
+      "GeForce 830A > 945A": {
+        "BOARD": "GeForce 830A > 945A",
+        "FAMILY": "Maxwell\u00a0(1st\u00a0Gen)",
+        "CHIP": "GM108",
+        "Desktop/Mobile/Server": "M",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": "0",
+        "Total # of NVENC": "0",
+        "Max # of concurrent sessions": NaN,
+        "H.264 (AVCHD) YUV 4:2:0": false,
+        "H.264 (AVCHD) YUV 4:4:4": false,
+        "H.264 (AVCHD) Lossless": false,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": false,
+        "hevc": false
+      },
+      "GeForce 830M > 945M": {
+        "BOARD": "GeForce 830M > 945M",
+        "FAMILY": "Maxwell\u00a0(1st\u00a0Gen)",
+        "CHIP": "GM108",
+        "Desktop/Mobile/Server": "M",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": "0",
+        "Total # of NVENC": "0",
+        "Max # of concurrent sessions": NaN,
+        "H.264 (AVCHD) YUV 4:2:0": false,
+        "H.264 (AVCHD) YUV 4:4:4": false,
+        "H.264 (AVCHD) Lossless": false,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": false,
+        "hevc": false
+      },
+      "GeForce GTX 920MX - 940MX": {
+        "BOARD": "GeForce GTX 920MX - 940MX",
+        "FAMILY": "Maxwell\u00a0(1st\u00a0Gen)",
+        "CHIP": "GM108",
+        "Desktop/Mobile/Server": "M",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": "0",
+        "Total # of NVENC": "0",
+        "Max # of concurrent sessions": NaN,
+        "H.264 (AVCHD) YUV 4:2:0": false,
+        "H.264 (AVCHD) YUV 4:4:4": false,
+        "H.264 (AVCHD) Lossless": false,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": false,
+        "hevc": false
+      },
+      "GeForce MX110 / MX130": {
+        "BOARD": "GeForce MX110 / MX130",
+        "FAMILY": "Maxwell\u00a0(1st\u00a0Gen)",
+        "CHIP": "GM108",
+        "Desktop/Mobile/Server": "M",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": "0",
+        "Total # of NVENC": "0",
+        "Max # of concurrent sessions": NaN,
+        "H.264 (AVCHD) YUV 4:2:0": false,
+        "H.264 (AVCHD) YUV 4:4:4": false,
+        "H.264 (AVCHD) Lossless": false,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": false,
+        "hevc": false
+      },
+      "GeForce GTX 750 GeForce GTX 950 - 960": {
+        "BOARD": "GeForce GTX 750 GeForce GTX 950 - 960",
+        "FAMILY": "Maxwell\u00a0(2nd\u00a0Gen)",
+        "CHIP": "GM206",
+        "Desktop/Mobile/Server": "D",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": "1",
+        "Total # of NVENC": "1",
+        "Max # of concurrent sessions": 2.0,
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": true
+      },
+      "GeForce GTX 965M": {
+        "BOARD": "GeForce GTX 965M",
+        "FAMILY": "Maxwell\u00a0(2nd\u00a0Gen)",
+        "CHIP": "GM206",
+        "Desktop/Mobile/Server": "M",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": "1",
+        "Total # of NVENC": "1",
+        "Max # of concurrent sessions": 2.0,
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": true
+      },
+      "GeForce GTX 910M / 920M / 920A": {
+        "BOARD": "GeForce GTX 910M / 920M / 920A",
+        "FAMILY": "Maxwell\u00a0(2nd\u00a0Gen)",
+        "CHIP": "GM208B",
+        "Desktop/Mobile/Server": "M",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": "1",
+        "Total # of NVENC": "1",
+        "Max # of concurrent sessions": 2.0,
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": false,
+        "H.264 (AVCHD) Lossless": false,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": false
+      },
+      "GeForce GTX 965M > 980M / 980MX": {
+        "BOARD": "GeForce GTX 965M > 980M / 980MX",
+        "FAMILY": "Maxwell\u00a0(2nd\u00a0Gen)",
+        "CHIP": "GM204",
+        "Desktop/Mobile/Server": "M",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": "2",
+        "Total # of NVENC": "2",
+        "Max # of concurrent sessions": 2.0,
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": true
+      },
+      "GeForce GTX 960 Ti - 980": {
+        "BOARD": "GeForce GTX 960 Ti - 980",
+        "FAMILY": "Maxwell\u00a0(2nd\u00a0Gen)",
+        "CHIP": "GM204",
+        "Desktop/Mobile/Server": "D",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": "2",
+        "Total # of NVENC": "2",
+        "Max # of concurrent sessions": 2.0,
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": true
+      },
+      "GeForce GTX 980 Ti": {
+        "BOARD": "GeForce GTX 980 Ti",
+        "FAMILY": "Maxwell\u00a0(2nd\u00a0Gen)",
+        "CHIP": "GM200",
+        "Desktop/Mobile/Server": "D",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": "2",
+        "Total # of NVENC": "2",
+        "Max # of concurrent sessions": 2.0,
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": true
+      },
+      "GeForce GTX Titan X": {
+        "BOARD": "GeForce GTX Titan X",
+        "FAMILY": "Maxwell\u00a0(2nd\u00a0Gen)",
+        "CHIP": "GM200",
+        "Desktop/Mobile/Server": "D",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": "2",
+        "Total # of NVENC": "2",
+        "Max # of concurrent sessions": 2.0,
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": true
+      },
+      "GeForce MX150 > MX250": {
+        "BOARD": "GeForce MX150 > MX250",
+        "FAMILY": "Pascal",
+        "CHIP": "GP108",
+        "Desktop/Mobile/Server": "M",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": "0",
+        "Total # of NVENC": "0",
+        "Max # of concurrent sessions": 0.0,
+        "H.264 (AVCHD) YUV 4:2:0": false,
+        "H.264 (AVCHD) YUV 4:4:4": false,
+        "H.264 (AVCHD) Lossless": false,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": false,
+        "hevc": false
+      },
+      "Quadro K420 / K600": {
+        "BOARD": "Quadro K420 / K600",
+        "FAMILY": "Kepler",
+        "CHIP": "GK107",
+        "Desktop/Mobile/Server": "D",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": 1,
+        "Total # of NVENC": 1,
+        "Max # of concurrent sessions": "2",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": false,
+        "H.264 (AVCHD) Lossless": false,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": false
+      },
+      "Quadro K2000 / K2000D": {
+        "BOARD": "Quadro K2000 / K2000D",
+        "FAMILY": "Kepler",
+        "CHIP": "GK107",
+        "Desktop/Mobile/Server": "D",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": 1,
+        "Total # of NVENC": 1,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": false,
+        "H.264 (AVCHD) Lossless": false,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": false
+      },
+      "Quadro K2100 > K5000": {
+        "BOARD": "Quadro K2100 > K5000",
+        "FAMILY": "Kepler",
+        "CHIP": "GK106",
+        "Desktop/Mobile/Server": "M",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": 1,
+        "Total # of NVENC": 1,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": false,
+        "H.264 (AVCHD) Lossless": false,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": false
+      },
+      "Quadro K4000": {
+        "BOARD": "Quadro K4000",
+        "FAMILY": "Kepler",
+        "CHIP": "GK106",
+        "Desktop/Mobile/Server": "D",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": 1,
+        "Total # of NVENC": 1,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": false,
+        "H.264 (AVCHD) Lossless": false,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": false
+      },
+      "Quadro K100 > K2000 + K5100": {
+        "BOARD": "Quadro K100 > K2000 + K5100",
+        "FAMILY": "Kepler",
+        "CHIP": "GK104",
+        "Desktop/Mobile/Server": "M",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": 1,
+        "Total # of NVENC": 1,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": false,
+        "H.264 (AVCHD) Lossless": false,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": false
+      },
+      "Quadro K4200 / K5000": {
+        "BOARD": "Quadro K4200 / K5000",
+        "FAMILY": "Kepler",
+        "CHIP": "GK104",
+        "Desktop/Mobile/Server": "D",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": 1,
+        "Total # of NVENC": 1,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": false,
+        "H.264 (AVCHD) Lossless": false,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": false
+      },
+      "Quadro K5200 / K6000": {
+        "BOARD": "Quadro K5200 / K6000",
+        "FAMILY": "Kepler (2nd Gen)",
+        "CHIP": "GK110B",
+        "Desktop/Mobile/Server": "D",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": 1,
+        "Total # of NVENC": 1,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": false,
+        "H.264 (AVCHD) Lossless": false,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": false
+      },
+      "Quadro K620 / K1200": {
+        "BOARD": "Quadro K620 / K1200",
+        "FAMILY": "Maxwell (1st Gen)",
+        "CHIP": "GM107",
+        "Desktop/Mobile/Server": "D",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": 1,
+        "Total # of NVENC": 1,
+        "Max # of concurrent sessions": "2",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": false
+      },
+      "Quadro K2200": {
+        "BOARD": "Quadro K2200",
+        "FAMILY": "Maxwell (1st Gen)",
+        "CHIP": "GM107",
+        "Desktop/Mobile/Server": "D",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": 1,
+        "Total # of NVENC": 1,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": false
+      },
+      "Quadro M500 / M520": {
+        "BOARD": "Quadro M500 / M520",
+        "FAMILY": "Maxwell (1st Gen)",
+        "CHIP": "GM108",
+        "Desktop/Mobile/Server": "M",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": 0,
+        "Total # of NVENC": 0,
+        "Max # of concurrent sessions": NaN,
+        "H.264 (AVCHD) YUV 4:2:0": false,
+        "H.264 (AVCHD) YUV 4:4:4": false,
+        "H.264 (AVCHD) Lossless": false,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": false,
+        "hevc": false
+      },
+      "Quadro M600 / M620": {
+        "BOARD": "Quadro M600 / M620",
+        "FAMILY": "Maxwell (1st Gen)",
+        "CHIP": "GM107",
+        "Desktop/Mobile/Server": "M",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": 1,
+        "Total # of NVENC": 1,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": false
+      },
+      "Quadro M1000 / M1200 / M2000": {
+        "BOARD": "Quadro M1000 / M1200 / M2000",
+        "FAMILY": "Maxwell (1st Gen)",
+        "CHIP": "GM107",
+        "Desktop/Mobile/Server": "M",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": 1,
+        "Total # of NVENC": 1,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": false
+      },
+      "Quadro M2000": {
+        "BOARD": "Quadro M2000",
+        "FAMILY": "Maxwell (GM206)",
+        "CHIP": "GM206",
+        "Desktop/Mobile/Server": "D",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": 1,
+        "Total # of NVENC": 1,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": true
+      },
+      "Quadro M2200": {
+        "BOARD": "Quadro M2200",
+        "FAMILY": "Maxwell (GM206)",
+        "CHIP": "GM206",
+        "Desktop/Mobile/Server": "M",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": 1,
+        "Total # of NVENC": 1,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": true
+      },
+      "Quadro M3000 / M4000 / M5500": {
+        "BOARD": "Quadro M3000 / M4000 / M5500",
+        "FAMILY": "Maxwell (2nd Gen)",
+        "CHIP": "GM204",
+        "Desktop/Mobile/Server": "M",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": 2,
+        "Total # of NVENC": 2,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": true
+      },
+      "Quadro M4000 / M5000": {
+        "BOARD": "Quadro M4000 / M5000",
+        "FAMILY": "Maxwell (2nd Gen)",
+        "CHIP": "GM204",
+        "Desktop/Mobile/Server": "D",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": 2,
+        "Total # of NVENC": 2,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": true
+      },
+      "Quadro M6000": {
+        "BOARD": "Quadro M6000",
+        "FAMILY": "Maxwell\u00a0(2nd\u00a0Gen)",
+        "CHIP": "GM200",
+        "Desktop/Mobile/Server": "D",
+        "# OF CHIPS": 1,
+        "# OF NVENC/CHIP": 2,
+        "Total # of NVENC": 2,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": true
+      },
+      "GRID K1": {
+        "BOARD": "GRID K1",
+        "FAMILY": "Kepler",
+        "CHIP": "GK107",
+        "# OF CHIPS": 4.0,
+        "# OF NVENC/CHIP": 1.0,
+        "Total # of NVENC": 4.0,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": false,
+        "H.264 (AVCHD) Lossless": false,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": false
+      },
+      "GRID K2": {
+        "BOARD": "GRID K2",
+        "FAMILY": "Kepler",
+        "CHIP": "GK104",
+        "# OF CHIPS": 2.0,
+        "# OF NVENC/CHIP": 1.0,
+        "Total # of NVENC": 2.0,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": false,
+        "H.264 (AVCHD) Lossless": false,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": false
+      },
+      "GRID K340": {
+        "BOARD": "GRID K340",
+        "FAMILY": "Kepler",
+        "CHIP": "GK107",
+        "# OF CHIPS": 4.0,
+        "# OF NVENC/CHIP": 1.0,
+        "Total # of NVENC": 4.0,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": false,
+        "H.264 (AVCHD) Lossless": false,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": false
+      },
+      "GRID K520": {
+        "BOARD": "GRID K520",
+        "FAMILY": "Kepler",
+        "CHIP": "GK104",
+        "# OF CHIPS": 2.0,
+        "# OF NVENC/CHIP": 1.0,
+        "Total # of NVENC": 2.0,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": false,
+        "H.264 (AVCHD) Lossless": false,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": false
+      },
+      "Tesla K10": {
+        "BOARD": "Tesla K10",
+        "FAMILY": "Kepler",
+        "CHIP": "GK104",
+        "# OF CHIPS": 2.0,
+        "# OF NVENC/CHIP": 1.0,
+        "Total # of NVENC": 2.0,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": false,
+        "H.264 (AVCHD) Lossless": false,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": false
+      },
+      "Tesla K20X": {
+        "BOARD": "Tesla K20X",
+        "FAMILY": "Kepler",
+        "CHIP": "GK110",
+        "# OF CHIPS": 1.0,
+        "# OF NVENC/CHIP": 1.0,
+        "Total # of NVENC": 1.0,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": false,
+        "H.264 (AVCHD) Lossless": false,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": false
+      },
+      "Tesla K40": {
+        "BOARD": "Tesla K40",
+        "FAMILY": "Kepler",
+        "CHIP": "GK110B",
+        "# OF CHIPS": 1.0,
+        "# OF NVENC/CHIP": 1.0,
+        "Total # of NVENC": 1.0,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": false,
+        "H.264 (AVCHD) Lossless": false,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": false
+      },
+      "Tesla K80": {
+        "BOARD": "Tesla K80",
+        "FAMILY": "Kepler (2nd Gen)",
+        "CHIP": "GK210",
+        "# OF CHIPS": 2.0,
+        "# OF NVENC/CHIP": 1.0,
+        "Total # of NVENC": 2.0,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": false,
+        "H.264 (AVCHD) Lossless": false,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": false
+      },
+      "Tesla M10": {
+        "BOARD": "Tesla M10",
+        "FAMILY": "Maxwell (1st Gen)",
+        "CHIP": "GM107",
+        "# OF CHIPS": 4.0,
+        "# OF NVENC/CHIP": 1.0,
+        "Total # of NVENC": 4.0,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": false,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": false
+      },
+      "Tesla M4": {
+        "BOARD": "Tesla M4",
+        "FAMILY": "Maxwell (GM206)",
+        "CHIP": "GM206",
+        "# OF CHIPS": 1.0,
+        "# OF NVENC/CHIP": 1.0,
+        "Total # of NVENC": 1.0,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": true
+      },
+      "Tesla M40": {
+        "BOARD": "Tesla M40",
+        "FAMILY": "Maxwell\u00a0(2nd\u00a0Gen)",
+        "CHIP": "GM200",
+        "# OF CHIPS": 1.0,
+        "# OF NVENC/CHIP": 2.0,
+        "Total # of NVENC": 2.0,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": true
+      },
+      "Tesla M6": {
+        "BOARD": "Tesla M6",
+        "FAMILY": "Maxwell\u00a0(2nd\u00a0Gen)",
+        "CHIP": "GM204",
+        "# OF CHIPS": 1.0,
+        "# OF NVENC/CHIP": 2.0,
+        "Total # of NVENC": 2.0,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": true
+      },
+      "Tesla M60": {
+        "BOARD": "Tesla M60",
+        "FAMILY": "Maxwell\u00a0(2nd\u00a0Gen)",
+        "CHIP": "GM204",
+        "# OF CHIPS": 2.0,
+        "# OF NVENC/CHIP": 2.0,
+        "Total # of NVENC": 4.0,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": false,
+        "H.265 (HEVC) 4K Lossless": false,
+        "H.265 (HEVC) 8k": false,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": true
+      },
+      "Tesla P4": {
+        "BOARD": "Tesla P4",
+        "FAMILY": "Pascal",
+        "CHIP": "GP104",
+        "# OF CHIPS": 1.0,
+        "# OF NVENC/CHIP": 2.0,
+        "Total # of NVENC": 2.0,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": true,
+        "H.265 (HEVC) 4K Lossless": true,
+        "H.265 (HEVC) 8k": true,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": true
+      },
+      "Tesla P6": {
+        "BOARD": "Tesla P6",
+        "FAMILY": "Pascal",
+        "CHIP": "GP104",
+        "# OF CHIPS": 1.0,
+        "# OF NVENC/CHIP": 2.0,
+        "Total # of NVENC": 2.0,
+        "Max # of concurrent sessions": "Unrestricted",
+        "H.264 (AVCHD) YUV 4:2:0": true,
+        "H.264 (AVCHD) YUV 4:4:4": true,
+        "H.264 (AVCHD) Lossless": true,
+        "H.265 (HEVC) 4K YUV 4:2:0": true,
+        "H.265 (HEVC) 4K YUV 4:4:4": true,
+        "H.265 (HEVC) 4K Lossless": true,
+        "H.265 (HEVC) 8k": true,
+        "HEVC B Frame support": false,
+        "h264": true,
+        "hevc": true
       }
     }
   }

From 705473c26645490d28411c3a7c3ca2d25dc9b57c Mon Sep 17 00:00:00 2001
From: Ross Patterson <me@rpatterson.net>
Date: Sat, 10 Aug 2019 16:15:40 -0700
Subject: [PATCH 25/37] Detect: Preserve dict key order

---
 examples/get_detect_data.py | 17 ++++++++++-------
 ffmpeg/_detect.py           | 33 ++++++++++++++++++++-------------
 ffmpeg/_probe.py            |  8 +++++++-
 ffmpeg/detect.json          |  2 +-
 4 files changed, 38 insertions(+), 22 deletions(-)

diff --git a/examples/get_detect_data.py b/examples/get_detect_data.py
index 74d79627..edd042ab 100755
--- a/examples/get_detect_data.py
+++ b/examples/get_detect_data.py
@@ -4,6 +4,7 @@
 """
 
 import sys
+import collections
 import math
 import json
 
@@ -51,12 +52,12 @@ def get_hwaccel_data():
     platform_cols = api_avail_table.loc[0][1:]
     api_rows = api_avail_table[0][2:]
 
-    hwaccels = {}
-    hwaccels['api_avail'] = platforms = {}
+    hwaccels = collections.OrderedDict()
+    hwaccels['api_avail'] = platforms = collections.OrderedDict()
     for gpu_vendor_idx, gpu_vendor in enumerate(gpu_vendor_cols):
         platform = platform_cols[gpu_vendor_idx + 1]
         platform = PLATFORM_TO_PY.get(platform, platform)
-        gpu_vendors = platforms.setdefault(platform, {})
+        gpu_vendors = platforms.setdefault(platform, collections.OrderedDict())
         avail_hwaccels = gpu_vendors.setdefault(gpu_vendor, [])
         for api_idx, api in enumerate(api_rows):
             if api_avail_table[gpu_vendor_idx + 1][api_idx + 2] != 'N':
@@ -74,7 +75,9 @@ def get_nvidia_data():
     (
         nvenc_recent, nvenc_consumer, nvenc_workstation, nvenc_virt,
         nvdec_recent, nvdec_consumer, nvdec_workstation, nvdec_virt) = tables
-    nvidia = dict(lines=[], model_lines={}, boards={})
+    nvidia = collections.OrderedDict(
+        lines=[], model_lines=collections.OrderedDict(),
+        boards=collections.OrderedDict())
 
     # Compile aggregate data needed to parse individual rows
     for nvenc_table in (
@@ -99,7 +102,7 @@ def get_nvidia_data():
                 continue
 
             # Assemble the data for this row to use for each model or range
-            model_data = {}
+            model_data = collections.OrderedDict()
             for key, value in nvenc_row.items():
                 if value in {'YES', 'NO'}:
                     model_data[key] = value == 'YES'
@@ -125,7 +128,7 @@ def get_nvidia_data():
     # GTX model numbers
     for model_line, model_line_suffixes in NVIDIA_LINE_SUFFIXES.items():
         models_data = nvidia['model_lines'][model_line]['models']
-        for model_num in models_data:
+        for model_num in list(models_data):
             for model_line_suffix in model_line_suffixes:
                 if model_num.startswith(model_line_suffix + ' '):
                     models_data[model_num[
@@ -152,7 +155,7 @@ def main():
     """
     Download ffmpeg detection data.
     """
-    data = dict(
+    data = collections.OrderedDict(
         hwaccels=get_hwaccel_data(),
         nvidia=get_nvidia_data(),
     )
diff --git a/ffmpeg/_detect.py b/ffmpeg/_detect.py
index df1bbcf5..0cc5bed9 100644
--- a/ffmpeg/_detect.py
+++ b/ffmpeg/_detect.py
@@ -24,6 +24,7 @@
 import platform
 import os
 import copy
+import collections
 import re
 import json
 import logging
@@ -57,7 +58,7 @@
     'vaapi': 'vaapi'}
 
 GPU_PRODUCT_RE = re.compile(r'(?P<chip>[^[]+)(\[(?P<board>[^]]+)\]|)')
-GPU_WMI_PROPERTIES = dict(
+GPU_WMI_PROPERTIES = collections.OrderedDict(
     vendor='AdapterCompatibility', board='VideoProcessor')
 
 # Loaded from JSON
@@ -75,12 +76,14 @@ def detect_gpus():
         # TODO: Android and other Linux'es that don't have `lshw`
         display_output = subprocess.check_output(
             ['lshw', '-class', 'display', '-json'])
-        displays_data = json.loads(display_output.decode().strip().strip(','))
+        displays_data = json.loads(
+            display_output.decode().strip().strip(','),
+            object_pairs_hook=collections.OrderedDict)
         if not isinstance(displays_data, list):
             # TODO: Confirm this is how `lshw` handles multiple GPUs
             displays_data = [displays_data]
         for display_data in displays_data:
-            gpu = dict(
+            gpu = collections.OrderedDict(
                 vendor=display_data['vendor'].replace(' Corporation', ''))
             # TODO get multiple GPUs from lshw
             gpus.append(gpu)
@@ -94,7 +97,7 @@ def detect_gpus():
     elif plat_sys == 'Windows':
         import wmi
         for controller in wmi.WMI().Win32_VideoController():
-            gpu = {}
+            gpu = collections.OrderedDict()
             for key, wmi_prop in GPU_WMI_PROPERTIES.items():
                 value = controller.wmi_property(wmi_prop).value
                 if value:
@@ -179,7 +182,8 @@ def detect_codecs(decoder, encoder, hwaccels=None, cmd='ffmpeg'):
             'Could not detect a supported encoder for {0!r}'.format(encoder))
 
     codecs_kwargs = []
-    default_kwargs = dict(output=dict(codec=avail_encoders[0]))
+    default_kwargs = collections.OrderedDict(
+        output=collections.OrderedDict(codec=avail_encoders[0]))
     for hwaccel in hwaccels_data['hwaccels']:
 
         if hwaccel['codecs']:
@@ -190,9 +194,9 @@ def detect_codecs(decoder, encoder, hwaccels=None, cmd='ffmpeg'):
                 # Remove hwaccel codecs from future consideration.
                 hwaccel_encoder = hwaccel_encoder
                 avail_encoders.remove(hwaccel_encoder)
-                hwaccel_kwargs = dict(
-                    input=dict(hwaccel=hwaccel['name']),
-                    output=dict(codec=hwaccel_encoder))
+                hwaccel_kwargs = collections.OrderedDict(
+                    input=collections.OrderedDict(hwaccel=hwaccel['name']),
+                    output=collections.OrderedDict(codec=hwaccel_encoder))
                 if hwaccel['name'] in HWACCEL_OUTPUT_FORMATS:
                     hwaccel_kwargs['input']['hwaccel_output_format'] = (
                         HWACCEL_OUTPUT_FORMATS[hwaccel['name']])
@@ -210,7 +214,8 @@ def detect_codecs(decoder, encoder, hwaccels=None, cmd='ffmpeg'):
         else:
             # This hwaccel doesn't require specific coders.
             hwaccel_kwargs = copy.deepcopy(default_kwargs)
-            hwaccel_kwargs['input'] = dict(hwaccel=hwaccel['name'])
+            hwaccel_kwargs['input'] = collections.OrderedDict(
+                hwaccel=hwaccel['name'])
             codecs_kwargs.append(hwaccel_kwargs)
 
     codecs_kwargs.append(default_kwargs)
@@ -232,7 +237,8 @@ def _get_data():
     if DATA is None:
         with open(os.path.join(
                 os.path.dirname(__file__), 'detect.json')) as data_opened:
-            DATA = json.load(data_opened)
+            DATA = json.load(
+                data_opened, object_pairs_hook=collections.OrderedDict)
     return DATA
 
 
@@ -243,7 +249,7 @@ def _parse_models(
     Parse model lines, sets and ranges from a boards string.
     """
     if model_lines_data is None:
-        model_lines_data = {}
+        model_lines_data = collections.OrderedDict()
 
     boards = boards.strip().lower()
     model_line_positions = [
@@ -261,7 +267,8 @@ def _parse_models(
     if model_group:
         # First item is a model range for the previous model line
         model_line_data = model_lines_data.setdefault(
-            model_line, dict(models={}, model_ranges=[]))
+            model_line, collections.OrderedDict(
+                models=collections.OrderedDict(), model_ranges=[]))
 
         models = []
         for model_split in model_group.split('/'):
@@ -301,7 +308,7 @@ def main(args=None):
     Dump all ffmpeg build data to json.
     """
     args = parser.parse_args(args)
-    data = dict(
+    data = collections.OrderedDict(
         gpus=detect_gpus(),
         hwaccels=detect_hwaccels(cmd=args.ffmpeg),
         codecs=detect_codecs(cmd=args.ffmpeg))
diff --git a/ffmpeg/_probe.py b/ffmpeg/_probe.py
index 41e81680..be25d4bd 100644
--- a/ffmpeg/_probe.py
+++ b/ffmpeg/_probe.py
@@ -1,3 +1,8 @@
+"""
+Run ffprobe on the file and return a JSON representation of the output.
+"""
+
+import collections
 import json
 import subprocess
 from ._run import Error
@@ -21,7 +26,8 @@ def probe(filename, cmd='ffprobe', **kwargs):
     out, err = p.communicate()
     if p.returncode != 0:
         raise Error('ffprobe', out, err)
-    return json.loads(out.decode('utf-8'))
+    return json.loads(
+        out.decode('utf-8'), object_pairs_hook=collections.OrderedDict)
 
 
 __all__ = ['probe']
diff --git a/ffmpeg/detect.json b/ffmpeg/detect.json
index 68736e09..1067d105 100644
--- a/ffmpeg/detect.json
+++ b/ffmpeg/detect.json
@@ -130,8 +130,8 @@
           "920a": "GeForce GTX 910M / 920M / 920A",
           "980mx": "GeForce GTX 965M > 980M / 980MX",
           "980 ti": "GeForce GTX 980 Ti",
-          "titan xp": "GeForce GTX Titan X / Titan Xp",
           "titan black": "GeForce GTX Titan / Titan Black",
+          "titan xp": "GeForce GTX Titan X / Titan Xp",
           "titan x": "GeForce GTX Titan X / Titan Xp",
           "titan z": "GeForce GTX Titan Z",
           "titan": "GeForce GTX Titan / Titan Black"

From 8982e9fff25a6b2380948fb00f5bffa5f0ff80e5 Mon Sep 17 00:00:00 2001
From: Ross Patterson <me@rpatterson.net>
Date: Sat, 10 Aug 2019 16:16:02 -0700
Subject: [PATCH 26/37] Detect: Whitespace cleanup

---
 examples/get_detect_data.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/examples/get_detect_data.py b/examples/get_detect_data.py
index edd042ab..1fdaba64 100755
--- a/examples/get_detect_data.py
+++ b/examples/get_detect_data.py
@@ -108,8 +108,7 @@ def get_nvidia_data():
                     model_data[key] = value == 'YES'
                 else:
                     model_data[key] = value
-            model_data['BOARD'] = model_data['BOARD'].replace(
-                '\xa0', ' ')
+            model_data['BOARD'] = model_data['BOARD'].replace('\xa0', ' ')
             # Add keys for the data for the ffmpeg codec names for fast lookup
             for codec_prefix, codec in NVIDIA_CODEC_COLUMN_PREFIXES.items():
                 for column_idx, column in enumerate(nvenc_row.keys()):

From 9f00ffd9950ee56ca2567335a1c2ff8bb980bd2d Mon Sep 17 00:00:00 2001
From: Ross Patterson <me@rpatterson.net>
Date: Sat, 10 Aug 2019 17:24:15 -0700
Subject: [PATCH 27/37] Detect: Add NVidia decoders data

---
 examples/get_detect_data.py |  151 +-
 ffmpeg/detect.json          | 7339 +++++++++++++++++++++++++----------
 2 files changed, 5292 insertions(+), 2198 deletions(-)

diff --git a/examples/get_detect_data.py b/examples/get_detect_data.py
index 1fdaba64..20b76d75 100755
--- a/examples/get_detect_data.py
+++ b/examples/get_detect_data.py
@@ -38,7 +38,11 @@
 NVIDIA_GPU_MATRIX_URL = (
     'https://developer.nvidia.com/video-encode-decode-gpu-support-matrix')
 NVIDIA_LINE_SUFFIXES = {'geforce': ['gtx titan', 'gtx', 'gt', 'rtx']}
-NVIDIA_CODEC_COLUMN_PREFIXES = {'h.264': 'h264', 'h.265': 'hevc'}
+NVIDIA_CODEC_COLUMN_PREFIXES = {
+    'mpeg-1': 'mpeg1video', 'mpeg-2': 'mpeg2video',
+    'vc-1': 'vc1',
+    'vp8': 'vp8', 'vp9': 'vp9',
+    'h.264': 'h264', 'h.265': 'hevc'}
 
 
 def get_hwaccel_data():
@@ -75,14 +79,18 @@ def get_nvidia_data():
     (
         nvenc_recent, nvenc_consumer, nvenc_workstation, nvenc_virt,
         nvdec_recent, nvdec_consumer, nvdec_workstation, nvdec_virt) = tables
-    nvidia = collections.OrderedDict(
-        lines=[], model_lines=collections.OrderedDict(),
-        boards=collections.OrderedDict())
+    nv_coders = dict(
+        encoders=(
+            nvenc_recent, nvenc_consumer, nvenc_workstation, nvenc_virt),
+        decoders=(
+            nvdec_recent, nvdec_consumer, nvdec_workstation, nvdec_virt))
+    nvidia = collections.OrderedDict(lines=[])
 
     # Compile aggregate data needed to parse individual rows
-    for nvenc_table in (
-            nvenc_recent, nvenc_consumer, nvenc_workstation, nvenc_virt):
-        for board in nvenc_table['BOARD']:
+    for nv_coder_table in tables:
+        for board in nv_coder_table['BOARD']:
+            if board == 'BOARD':
+                continue
             line = board.replace('\xa0', ' ').split(None, 1)[0].lower()
             if line not in nvidia['lines']:
                 nvidia['lines'].append(line)
@@ -90,62 +98,79 @@ def get_nvidia_data():
         for line_suffix in reversed(line_suffixes):
             nvidia['lines'].insert(0, ' '.join((line, line_suffix)))
 
-    for nvenc_table in (
-            nvenc_recent, nvenc_consumer, nvenc_workstation, nvenc_virt):
-        for nvenc_row_idx, nvenc_row in nvenc_table.iterrows():
-            nvenc_row_values = {
-                idx: cell for idx, cell in enumerate(nvenc_row[1:]) if (
-                    cell and
-                    not (isinstance(cell, float) and math.isnan(cell)))}
-            if not nvenc_row_values:
-                # Divider row
-                continue
-
-            # Assemble the data for this row to use for each model or range
-            model_data = collections.OrderedDict()
-            for key, value in nvenc_row.items():
-                if value in {'YES', 'NO'}:
-                    model_data[key] = value == 'YES'
-                else:
-                    model_data[key] = value
-            model_data['BOARD'] = model_data['BOARD'].replace('\xa0', ' ')
-            # Add keys for the data for the ffmpeg codec names for fast lookup
-            for codec_prefix, codec in NVIDIA_CODEC_COLUMN_PREFIXES.items():
-                for column_idx, column in enumerate(nvenc_row.keys()):
-                    if column.lower().startswith(codec_prefix):
-                        model_data[codec] = nvenc_row[column_idx] == 'YES'
-                        break
-            nvidia['boards'][model_data['BOARD']] = model_data
-
-            _detect._parse_models(
-                model_lines=nvidia['lines'],
-                boards=model_data['BOARD'].lower(),
-                model_data=model_data['BOARD'],
-                model_lines_data=nvidia['model_lines'])
-
-    # Clean up some annoying clashes between the titan model line and GeForce
-    # GTX model numbers
-    for model_line, model_line_suffixes in NVIDIA_LINE_SUFFIXES.items():
-        models_data = nvidia['model_lines'][model_line]['models']
-        for model_num in list(models_data):
-            for model_line_suffix in model_line_suffixes:
-                if model_num.startswith(model_line_suffix + ' '):
-                    models_data[model_num[
-                        len(model_line_suffix + ' '):]] = models_data.pop(
-                            model_num)
-    for titan_model_num in {'black', 'xp'}:
-        nvidia['model_lines']['geforce gtx']['models'][
-            'titan ' + titan_model_num] = nvidia['model_lines'][
-                'titan']['models'].pop(titan_model_num)
-    for titan_model_num in list(nvidia['model_lines'][
-            'geforce gtx titan']['models'].keys()):
-        nvidia['model_lines']['geforce gtx']['models'][
-            'titan ' + titan_model_num] = nvidia['model_lines'][
-                'geforce gtx titan']['models'].pop(titan_model_num)
-    nvidia['model_lines']['geforce gtx']['models']['titan'] = nvidia[
-        'model_lines']['geforce gtx']['models']['titan black']
-    del nvidia['model_lines']['geforce gtx']['models']['titan ']
-    del nvidia['model_lines']['geforce gtx titan']
+    for coder_type, nv_coder_tables in nv_coders.items():
+        coder_data = nvidia[coder_type] = collections.OrderedDict(
+            model_lines=collections.OrderedDict(),
+            boards=collections.OrderedDict())
+        for nv_coder_table in nv_coder_tables:
+            for nv_coder_row_idx, nv_coder_row in nv_coder_table.iterrows():
+                nv_coder_row_values = {
+                    idx: cell for idx, cell in enumerate(nv_coder_row[1:]) if (
+                        cell and
+                        not (isinstance(cell, float) and math.isnan(cell)))}
+                if not nv_coder_row_values:
+                    # Divider row
+                    continue
+
+                # Assemble the data for this row to use for each model or range
+                model_data = collections.OrderedDict()
+                for key, value in nv_coder_row.items():
+                    if isinstance(key, tuple):
+                        if key[0] == key[1]:
+                            key = key[0]
+                        else:
+                            key = ' '.join(key)
+                    if value in {'YES', 'NO'}:
+                        model_data[key] = value == 'YES'
+                    else:
+                        model_data[key] = value
+                model_data['BOARD'] = model_data['BOARD'].replace('\xa0', ' ')
+                # Add keys for the ffmpeg codec names for fast lookup
+                for codec_prefix, codec in (
+                        NVIDIA_CODEC_COLUMN_PREFIXES.items()):
+                    for column_idx, column in enumerate(nv_coder_row.keys()):
+                        if isinstance(column, tuple):
+                            if column[0] == column[1]:
+                                column = column[0]
+                            else:
+                                column = ' '.join(column)
+                        if column.lower().startswith(codec_prefix):
+                            model_data[codec] = nv_coder_row[
+                                column_idx] == 'YES'
+                            break
+                coder_data['boards'][model_data['BOARD']] = model_data
+
+                _detect._parse_models(
+                    model_lines=nvidia['lines'],
+                    boards=model_data['BOARD'].lower(),
+                    model_data=model_data['BOARD'],
+                    model_lines_data=coder_data['model_lines'])
+
+        # Cleanup any deviations from the convention where models from
+        # multiple lines are in the same BOARD cell
+        for model_line, model_line_data in coder_data['model_lines'].items():
+            for line, line_suffixes in NVIDIA_LINE_SUFFIXES.items():
+                if not model_line.startswith(line):
+                    continue
+                for model_num, boards in list(
+                        model_line_data['models'].items()):
+                    for line_suffix in line_suffixes:
+                        if not model_num.startswith(line_suffix + ' '):
+                            continue
+                        coder_data['model_lines'][
+                            ' '.join((line, line_suffix))]['models'][
+                                model_num[len(line_suffix + ' '):]
+                            ] = model_line_data['models'].pop(model_num)
+        # Clean up some annoying clashes between the titan model line and
+        # GeForce GTX model numbers
+        del coder_data['model_lines']['geforce gtx titan']['models']['']
+        coder_data['model_lines']['geforce gtx titan']['models'][
+            'xp'] = coder_data['model_lines']['titan']['models'].pop('xp')
+        coder_data['model_lines']['geforce gtx titan']['models'][
+            'black'] = titan_black = coder_data['model_lines'][
+                'titan']['models'].pop('black')
+        coder_data['model_lines']['geforce gtx']['models'][
+            'titan'] = titan_black
 
     return nvidia
 
diff --git a/ffmpeg/detect.json b/ffmpeg/detect.json
index 1067d105..e207a46c 100644
--- a/ffmpeg/detect.json
+++ b/ffmpeg/detect.json
@@ -80,2150 +80,5219 @@
       "tesla",
       "grid"
     ],
-    "model_lines": {
-      "geforce gt": {
-        "models": {
-          "1030": "GeForce GT 1030",
-          "723a": "GeForce GT 723A / 740A",
-          "740a": "GeForce GT 723A / 740A",
-          "630": "GeForce GT 630 / 635/ 640 / 710 / 730",
-          "635": "GeForce GT 630 / 635/ 640 / 710 / 730",
-          "640": "GeForce GT 630 / 635/ 640 / 710 / 730",
-          "710": "GeForce GT 630 / 635/ 640 / 710 / 730",
-          "730": "GeForce GT 630 / 635/ 640 / 710 / 730",
-          "740": "GeForce GTX 645 -660 Ti Boost GeForce GT 740"
-        },
-        "model_ranges": [
-          [
-            "720m > 740m",
-            "GeForce GT 720M > 740M"
-          ],
-          [
-            "630 > 640",
-            "GeForce GT 630 > 640 GeForce GTX 650 GeForce GT 740"
-          ],
-          [
-            "780 - 780 ti",
-            "GeForce GT 780 - 780 Ti"
+    "encoders": {
+      "model_lines": {
+        "geforce gt": {
+          "models": {
+            "1030": "GeForce GT 1030",
+            "723a": "GeForce GT 723A / 740A",
+            "740a": "GeForce GT 723A / 740A",
+            "630": "GeForce GT 630 / 635/ 640 / 710 / 730",
+            "635": "GeForce GT 630 / 635/ 640 / 710 / 730",
+            "640": "GeForce GT 630 / 635/ 640 / 710 / 730",
+            "710": "GeForce GT 630 / 635/ 640 / 710 / 730",
+            "730": "GeForce GT 630 / 635/ 640 / 710 / 730",
+            "740": "GeForce GTX 645 -660 Ti Boost GeForce GT 740"
+          },
+          "model_ranges": [
+            [
+              "720m > 740m",
+              "GeForce GT 720M > 740M"
+            ],
+            [
+              "630 > 640",
+              "GeForce GT 630 > 640 GeForce GTX 650 GeForce GT 740"
+            ],
+            [
+              "780 - 780 ti",
+              "GeForce GT 780 - 780 Ti"
+            ]
           ]
-        ]
-      },
-      "geforce gtx": {
-        "models": {
-          "1050": "GeForce GTX 1050 / 1050 Ti",
-          "1050 ti": "GeForce GTX 1050 / 1050 Ti",
-          "1060": "GeForce GTX 1060",
-          "1070m": "GeForce GTX 1070M / 1080M",
-          "1080m": "GeForce GTX 1070M / 1080M",
-          "1070": "GeForce GTX 1070 / 1070Ti",
-          "1070ti": "GeForce GTX 1070 / 1070Ti",
-          "1080": "GeForce GTX 1080",
-          "1080 ti": "GeForce GTX 1080 Ti",
-          "1650": "GeForce GTX 1650",
-          "1660 ti": "GeForce GTX 1660 Ti / 1660",
-          "1660": "GeForce GTX 1660 Ti / 1660",
-          "650": "GeForce GT 630 > 640 GeForce GTX 650 GeForce GT 740",
-          "750": "GeForce GTX 750 GeForce GTX 950 - 960",
-          "965m": "GeForce GTX 965M",
-          "910m": "GeForce GTX 910M / 920M / 920A",
-          "920m": "GeForce GTX 910M / 920M / 920A",
-          "920a": "GeForce GTX 910M / 920M / 920A",
-          "980mx": "GeForce GTX 965M > 980M / 980MX",
-          "980 ti": "GeForce GTX 980 Ti",
-          "titan black": "GeForce GTX Titan / Titan Black",
-          "titan xp": "GeForce GTX Titan X / Titan Xp",
-          "titan x": "GeForce GTX Titan X / Titan Xp",
-          "titan z": "GeForce GTX Titan Z",
-          "titan": "GeForce GTX Titan / Titan Black"
-        },
-        "model_ranges": [
-          [
-            "645 -660 ti boost",
-            "GeForce GTX 645 -660 Ti Boost GeForce GT 740"
-          ],
-          [
-            "660 - 690",
-            "GeForce GTX 660 - 690 GeForce GTX 760 - 770"
-          ],
-          [
-            "760 - 770",
-            "GeForce GTX 660 - 690 GeForce GTX 760 - 770"
-          ],
-          [
-            "745 - 750 ti",
-            "GeForce GTX 745 - 750 Ti"
-          ],
-          [
-            "850a > 960a",
-            "GeForce GTX 850A > 960A"
-          ],
-          [
-            "850m > 960m",
-            "GeForce GTX 850M > 960M"
-          ],
-          [
-            "920mx - 940mx",
-            "GeForce GTX 920MX - 940MX"
-          ],
-          [
-            "950 - 960",
-            "GeForce GTX 750 GeForce GTX 950 - 960"
-          ],
-          [
-            "965m > 980m",
-            "GeForce GTX 965M > 980M / 980MX"
-          ],
-          [
-            "960 ti - 980",
-            "GeForce GTX 960 Ti - 980"
+        },
+        "geforce gtx": {
+          "models": {
+            "1050": "GeForce GTX 1050 / 1050 Ti",
+            "1050 ti": "GeForce GTX 1050 / 1050 Ti",
+            "1060": "GeForce GTX 1060",
+            "1070m": "GeForce GTX 1070M / 1080M",
+            "1080m": "GeForce GTX 1070M / 1080M",
+            "1070": "GeForce GTX 1070 / 1070Ti",
+            "1070ti": "GeForce GTX 1070 / 1070Ti",
+            "1080": "GeForce GTX 1080",
+            "1080 ti": "GeForce GTX 1080 Ti",
+            "1650": "GeForce GTX 1650",
+            "1660 ti": "GeForce GTX 1660 Ti / 1660",
+            "1660": "GeForce GTX 1660 Ti / 1660",
+            "650": "GeForce GT 630 > 640 GeForce GTX 650 GeForce GT 740",
+            "750": "GeForce GTX 750 GeForce GTX 950 - 960",
+            "965m": "GeForce GTX 965M",
+            "910m": "GeForce GTX 910M / 920M / 920A",
+            "920m": "GeForce GTX 910M / 920M / 920A",
+            "920a": "GeForce GTX 910M / 920M / 920A",
+            "980mx": "GeForce GTX 965M > 980M / 980MX",
+            "980 ti": "GeForce GTX 980 Ti",
+            "660m": "GeForce 640M > GT 755M / GTX 660M",
+            "titan": "GeForce GTX Titan / Titan Black"
+          },
+          "model_ranges": [
+            [
+              "645 -660 ti boost",
+              "GeForce GTX 645 -660 Ti Boost GeForce GT 740"
+            ],
+            [
+              "660 - 690",
+              "GeForce GTX 660 - 690 GeForce GTX 760 - 770"
+            ],
+            [
+              "760 - 770",
+              "GeForce GTX 660 - 690 GeForce GTX 760 - 770"
+            ],
+            [
+              "745 - 750 ti",
+              "GeForce GTX 745 - 750 Ti"
+            ],
+            [
+              "850a > 960a",
+              "GeForce GTX 850A > 960A"
+            ],
+            [
+              "850m > 960m",
+              "GeForce GTX 850M > 960M"
+            ],
+            [
+              "920mx - 940mx",
+              "GeForce GTX 920MX - 940MX"
+            ],
+            [
+              "950 - 960",
+              "GeForce GTX 750 GeForce GTX 950 - 960"
+            ],
+            [
+              "965m > 980m",
+              "GeForce GTX 965M > 980M / 980MX"
+            ],
+            [
+              "960 ti - 980",
+              "GeForce GTX 960 Ti - 980"
+            ]
           ]
-        ]
-      },
-      "titan": {
-        "models": {
-          "v": "Titan V",
-          "rtx": "Titan RTX"
         },
-        "model_ranges": []
-      },
-      "geforce rtx": {
-        "models": {
-          "2060": "GeForce RTX 2060 / 2070",
-          "2070": "GeForce RTX 2060 / 2070",
-          "2080": "GeForce RTX 2080",
-          "2080 ti": "GeForce RTX 2080 Ti"
-        },
-        "model_ranges": []
-      },
-      "quadro": {
-        "models": {
-          "p500": "Quadro P500 / P520",
-          "p520": "Quadro P500 / P520",
-          "p400": "Quadro P400",
-          "p600": "Quadro P600 / P1000",
-          "p1000": "Quadro P600 / P1000",
-          "p2000": "Quadro P2000 / P2200",
-          "p2200": "Quadro P2000 / P2200",
-          "p3200": "Quadro P3200 / P4200 / P5200",
-          "p4200": "Quadro P3200 / P4200 / P5200",
-          "p5200": "Quadro P3200 / P4200 / P5200",
-          "p4000": "Quadro P4000",
-          "p5000": "Quadro P5000",
-          "p6000": "Quadro P6000",
-          "gp100": "Quadro GP100",
-          "gv100": "Quadro GV100",
-          "t1000": "Quadro T1000",
-          "t2000": "Quadro T2000",
-          "rtx 3000": "Quadro RTX 3000",
-          "rtx 5000": "Quadro RTX 5000/RTX 4000",
-          "rtx 4000": "Quadro RTX 5000/RTX 4000",
-          "rtx 6000": "Quadro RTX 6000/RTX 8000",
-          "rtx 8000": "Quadro RTX 6000/RTX 8000",
-          "k420": "Quadro K420 / K600",
-          "k600": "Quadro K420 / K600",
-          "k2000": "Quadro K2000 / K2000D",
-          "k2000d": "Quadro K2000 / K2000D",
-          "k4000": "Quadro K4000",
-          "k5100": "Quadro K100 > K2000 + K5100",
-          "k4200": "Quadro K4200 / K5000",
-          "k5000": "Quadro K4200 / K5000",
-          "k5200": "Quadro K5200 / K6000",
-          "k6000": "Quadro K5200 / K6000",
-          "k620": "Quadro K620 / K1200",
-          "k1200": "Quadro K620 / K1200",
-          "k2200": "Quadro K2200",
-          "m500": "Quadro M500 / M520",
-          "m520": "Quadro M500 / M520",
-          "m600": "Quadro M600 / M620",
-          "m620": "Quadro M600 / M620",
-          "m1000": "Quadro M1000 / M1200 / M2000",
-          "m1200": "Quadro M1000 / M1200 / M2000",
-          "m2000": "Quadro M2000",
-          "m2200": "Quadro M2200",
-          "m3000": "Quadro M3000 / M4000 / M5500",
-          "m4000": "Quadro M4000 / M5000",
-          "m5500": "Quadro M3000 / M4000 / M5500",
-          "m5000": "Quadro M4000 / M5000",
-          "m6000": "Quadro M6000"
-        },
-        "model_ranges": [
-          [
-            "k2100 > k5000",
-            "Quadro K2100 > K5000"
-          ],
-          [
-            "k100 > k2000",
-            "Quadro K100 > K2000 + K5100"
+        "geforce gtx titan": {
+          "models": {
+            "x": "GeForce GTX Titan X / Titan Xp",
+            "z": "GeForce GTX Titan Z",
+            "xp": "GeForce GTX Titan X / Titan Xp",
+            "black": "GeForce GTX Titan / Titan Black"
+          },
+          "model_ranges": []
+        },
+        "titan": {
+          "models": {
+            "v": "Titan V",
+            "rtx": "Titan RTX"
+          },
+          "model_ranges": []
+        },
+        "geforce rtx": {
+          "models": {
+            "2060": "GeForce RTX 2060 / 2070",
+            "2070": "GeForce RTX 2060 / 2070",
+            "2080": "GeForce RTX 2080",
+            "2080 ti": "GeForce RTX 2080 Ti"
+          },
+          "model_ranges": []
+        },
+        "quadro": {
+          "models": {
+            "p500": "Quadro P500 / P520",
+            "p520": "Quadro P500 / P520",
+            "p400": "Quadro P400",
+            "p600": "Quadro P600 / P1000",
+            "p1000": "Quadro P600 / P1000",
+            "p2000": "Quadro P2000 / P2200",
+            "p2200": "Quadro P2000 / P2200",
+            "p3200": "Quadro P3200 / P4200 / P5200",
+            "p4200": "Quadro P3200 / P4200 / P5200",
+            "p5200": "Quadro P3200 / P4200 / P5200",
+            "p4000": "Quadro P4000",
+            "p5000": "Quadro P5000",
+            "p6000": "Quadro P6000",
+            "gp100": "Quadro GP100",
+            "gv100": "Quadro GV100",
+            "t1000": "Quadro T1000",
+            "t2000": "Quadro T2000",
+            "rtx 3000": "Quadro RTX 3000",
+            "rtx 5000": "Quadro RTX 5000/RTX 4000",
+            "rtx 4000": "Quadro RTX 5000/RTX 4000",
+            "rtx 6000": "Quadro RTX 6000/RTX 8000",
+            "rtx 8000": "Quadro RTX 6000/RTX 8000",
+            "k420": "Quadro K420 / K600",
+            "k600": "Quadro K420 / K600",
+            "k2000": "Quadro K2000 / K2000D",
+            "k2000d": "Quadro K2000 / K2000D",
+            "k4000": "Quadro K4000",
+            "k5100": "Quadro K100 > K2000 + K5100",
+            "k4200": "Quadro K4200 / K5000",
+            "k5000": "Quadro K4200 / K5000",
+            "k5200": "Quadro K5200 / K6000",
+            "k6000": "Quadro K5200 / K6000",
+            "k620": "Quadro K620 / K1200",
+            "k1200": "Quadro K620 / K1200",
+            "k2200": "Quadro K2200",
+            "m500": "Quadro M500 / M520",
+            "m520": "Quadro M500 / M520",
+            "m600": "Quadro M600 / M620",
+            "m620": "Quadro M600 / M620",
+            "m1000": "Quadro M1000 / M1200 / M2000",
+            "m1200": "Quadro M1000 / M1200 / M2000",
+            "m2000": "Quadro M2000",
+            "m2200": "Quadro M2200",
+            "m3000": "Quadro M3000 / M4000 / M5500",
+            "m4000": "Quadro M4000 / M5000",
+            "m5500": "Quadro M3000 / M4000 / M5500",
+            "m5000": "Quadro M4000 / M5000",
+            "m6000": "Quadro M6000"
+          },
+          "model_ranges": [
+            [
+              "k2100 > k5000",
+              "Quadro K2100 > K5000"
+            ],
+            [
+              "k100 > k2000",
+              "Quadro K100 > K2000 + K5100"
+            ]
           ]
-        ]
-      },
-      "tesla": {
-        "models": {
-          "p4": "Tesla P4",
-          "p6": "Tesla P6",
-          "p40": "Tesla P40",
-          "p100": "Tesla P100",
-          "v100": "Tesla V100",
-          "t4": "Tesla T4",
-          "k10": "Tesla K10",
-          "k20x": "Tesla K20X",
-          "k40": "Tesla K40",
-          "k80": "Tesla K80",
-          "m10": "Tesla M10",
-          "m4": "Tesla M4",
-          "m40": "Tesla M40",
-          "m6": "Tesla M6",
-          "m60": "Tesla M60"
-        },
-        "model_ranges": []
-      },
-      "geforce": {
-        "models": {
-          "710a": "GeForce 710A / 810M / 820M",
-          "810m": "GeForce 710A / 810M / 820M",
-          "820m": "GeForce 710A / 810M / 820M",
-          "845m": "GeForce 845M / 940M / 940MX / 945M",
-          "940m": "GeForce 845M / 940M / 940MX / 945M",
-          "940mx": "GeForce 845M / 940M / 940MX / 945M",
-          "945m": "GeForce 845M / 940M / 940MX / 945M",
-          "mx110": "GeForce MX110 / MX130",
-          "mx130": "GeForce MX110 / MX130",
-          "660m": "GeForce 640M > GT 755M / GTX 660M"
-        },
-        "model_ranges": [
-          [
-            "710a > 810a",
-            "GeForce 710A > 810A"
-          ],
-          [
-            "640m > gt 755m",
-            "GeForce 640M > GT 755M / GTX 660M"
-          ],
-          [
-            "830a > 945a",
-            "GeForce 830A > 945A"
-          ],
-          [
-            "830m > 945m",
-            "GeForce 830M > 945M"
-          ],
-          [
-            "mx150 > mx250",
-            "GeForce MX150 > MX250"
+        },
+        "tesla": {
+          "models": {
+            "p4": "Tesla P4",
+            "p6": "Tesla P6",
+            "p40": "Tesla P40",
+            "p100": "Tesla P100",
+            "v100": "Tesla V100",
+            "t4": "Tesla T4",
+            "k10": "Tesla K10",
+            "k20x": "Tesla K20X",
+            "k40": "Tesla K40",
+            "k80": "Tesla K80",
+            "m10": "Tesla M10",
+            "m4": "Tesla M4",
+            "m40": "Tesla M40",
+            "m6": "Tesla M6",
+            "m60": "Tesla M60"
+          },
+          "model_ranges": []
+        },
+        "geforce": {
+          "models": {
+            "710a": "GeForce 710A / 810M / 820M",
+            "810m": "GeForce 710A / 810M / 820M",
+            "820m": "GeForce 710A / 810M / 820M",
+            "845m": "GeForce 845M / 940M / 940MX / 945M",
+            "940m": "GeForce 845M / 940M / 940MX / 945M",
+            "940mx": "GeForce 845M / 940M / 940MX / 945M",
+            "945m": "GeForce 845M / 940M / 940MX / 945M",
+            "mx110": "GeForce MX110 / MX130",
+            "mx130": "GeForce MX110 / MX130"
+          },
+          "model_ranges": [
+            [
+              "710a > 810a",
+              "GeForce 710A > 810A"
+            ],
+            [
+              "640m > gt 755m",
+              "GeForce 640M > GT 755M / GTX 660M"
+            ],
+            [
+              "830a > 945a",
+              "GeForce 830A > 945A"
+            ],
+            [
+              "830m > 945m",
+              "GeForce 830M > 945M"
+            ],
+            [
+              "mx150 > mx250",
+              "GeForce MX150 > MX250"
+            ]
           ]
-        ]
+        },
+        "grid": {
+          "models": {
+            "k1": "GRID K1",
+            "k2": "GRID K2",
+            "k340": "GRID K340",
+            "k520": "GRID K520"
+          },
+          "model_ranges": []
+        }
       },
-      "grid": {
-        "models": {
-          "k1": "GRID K1",
-          "k2": "GRID K2",
-          "k340": "GRID K340",
-          "k520": "GRID K520"
-        },
-        "model_ranges": []
+      "boards": {
+        "GeForce GT 1030": {
+          "BOARD": "GeForce GT 1030",
+          "FAMILY": "Pascal",
+          "CHIP": "GP108",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": "0",
+          "Total # of NVENC": "0",
+          "Max # of concurrent sessions": 0.0,
+          "H.264 (AVCHD) YUV 4:2:0": false,
+          "H.264 (AVCHD) YUV 4:4:4": false,
+          "H.264 (AVCHD) Lossless": false,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": false,
+          "hevc": false
+        },
+        "GeForce GTX 1050 / 1050 Ti": {
+          "BOARD": "GeForce GTX 1050 / 1050 Ti",
+          "FAMILY": "Pascal",
+          "CHIP": "GP106",
+          "Desktop/Mobile/Server": "D/M",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": "1",
+          "Total # of NVENC": "1",
+          "Max # of concurrent sessions": 2.0,
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": true,
+          "H.265 (HEVC) 4K Lossless": true,
+          "H.265 (HEVC) 8k": true,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": true
+        },
+        "GeForce GTX 1060": {
+          "BOARD": "GeForce GTX 1060",
+          "FAMILY": "Pascal",
+          "CHIP": "GP104",
+          "Desktop/Mobile/Server": "D/M",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": "1",
+          "Total # of NVENC": "1",
+          "Max # of concurrent sessions": 2.0,
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": true,
+          "H.265 (HEVC) 4K Lossless": true,
+          "H.265 (HEVC) 8k": true,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": true
+        },
+        "GeForce GTX 1070M / 1080M": {
+          "BOARD": "GeForce GTX 1070M / 1080M",
+          "FAMILY": "Pascal",
+          "CHIP": "GP104B",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": "2",
+          "Total # of NVENC": "2",
+          "Max # of concurrent sessions": 2.0,
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": true,
+          "H.265 (HEVC) 4K Lossless": true,
+          "H.265 (HEVC) 8k": true,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": true
+        },
+        "GeForce GTX 1070 / 1070Ti": {
+          "BOARD": "GeForce GTX 1070 / 1070Ti",
+          "FAMILY": "Pascal",
+          "CHIP": "GP104",
+          "Desktop/Mobile/Server": "D/M",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": "2",
+          "Total # of NVENC": "2",
+          "Max # of concurrent sessions": 2.0,
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": true,
+          "H.265 (HEVC) 4K Lossless": true,
+          "H.265 (HEVC) 8k": true,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": true
+        },
+        "GeForce GTX 1080": {
+          "BOARD": "GeForce GTX 1080",
+          "FAMILY": "Pascal",
+          "CHIP": "GP104",
+          "Desktop/Mobile/Server": "D/M",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": "2",
+          "Total # of NVENC": "2",
+          "Max # of concurrent sessions": 2.0,
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": true,
+          "H.265 (HEVC) 4K Lossless": true,
+          "H.265 (HEVC) 8k": true,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": true
+        },
+        "GeForce GTX 1080 Ti": {
+          "BOARD": "GeForce GTX 1080 Ti",
+          "FAMILY": "Pascal",
+          "CHIP": "GP102",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": "2",
+          "Total # of NVENC": "2",
+          "Max # of concurrent sessions": 2.0,
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": true,
+          "H.265 (HEVC) 4K Lossless": true,
+          "H.265 (HEVC) 8k": true,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": true
+        },
+        "GeForce GTX Titan X / Titan Xp": {
+          "BOARD": "GeForce GTX Titan X / Titan Xp",
+          "FAMILY": "Pascal",
+          "CHIP": "GP102",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": "2",
+          "Total # of NVENC": "2",
+          "Max # of concurrent sessions": 2.0,
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": true,
+          "H.265 (HEVC) 4K Lossless": true,
+          "H.265 (HEVC) 8k": true,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": true
+        },
+        "Titan V": {
+          "BOARD": "Titan V",
+          "FAMILY": "Volta",
+          "CHIP": "GV100",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": "3",
+          "Total # of NVENC": "3",
+          "Max # of concurrent sessions": 2.0,
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": true,
+          "H.265 (HEVC) 4K Lossless": true,
+          "H.265 (HEVC) 8k": true,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": true
+        },
+        "GeForce GTX 1650": {
+          "BOARD": "GeForce GTX 1650",
+          "FAMILY": "Turing*",
+          "CHIP": "TU117",
+          "Desktop/Mobile/Server": "D/M",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": "1*",
+          "Total # of NVENC": "1*",
+          "Max # of concurrent sessions": 2.0,
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": true,
+          "H.265 (HEVC) 4K Lossless": true,
+          "H.265 (HEVC) 8k": true,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": true
+        },
+        "GeForce GTX 1660 Ti / 1660": {
+          "BOARD": "GeForce GTX 1660 Ti / 1660",
+          "FAMILY": "Turing",
+          "CHIP": "TU116",
+          "Desktop/Mobile/Server": "D/M",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": "1",
+          "Total # of NVENC": "1",
+          "Max # of concurrent sessions": 2.0,
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": true,
+          "H.265 (HEVC) 4K Lossless": true,
+          "H.265 (HEVC) 8k": true,
+          "HEVC B Frame support": true,
+          "h264": true,
+          "hevc": true
+        },
+        "GeForce RTX 2060 / 2070": {
+          "BOARD": "GeForce RTX 2060 / 2070",
+          "FAMILY": "Turing",
+          "CHIP": "TU106",
+          "Desktop/Mobile/Server": "D/M",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": "1",
+          "Total # of NVENC": "1",
+          "Max # of concurrent sessions": 2.0,
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": true,
+          "H.265 (HEVC) 4K Lossless": true,
+          "H.265 (HEVC) 8k": true,
+          "HEVC B Frame support": true,
+          "h264": true,
+          "hevc": true
+        },
+        "GeForce RTX 2080": {
+          "BOARD": "GeForce RTX 2080",
+          "FAMILY": "Turing",
+          "CHIP": "TU104",
+          "Desktop/Mobile/Server": "D/M",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": "1",
+          "Total # of NVENC": "1",
+          "Max # of concurrent sessions": 2.0,
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": true,
+          "H.265 (HEVC) 4K Lossless": true,
+          "H.265 (HEVC) 8k": true,
+          "HEVC B Frame support": true,
+          "h264": true,
+          "hevc": true
+        },
+        "GeForce RTX 2080 Ti": {
+          "BOARD": "GeForce RTX 2080 Ti",
+          "FAMILY": "Turing",
+          "CHIP": "TU102",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": "1",
+          "Total # of NVENC": "1",
+          "Max # of concurrent sessions": 2.0,
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": true,
+          "H.265 (HEVC) 4K Lossless": true,
+          "H.265 (HEVC) 8k": true,
+          "HEVC B Frame support": true,
+          "h264": true,
+          "hevc": true
+        },
+        "Titan RTX": {
+          "BOARD": "Titan RTX",
+          "FAMILY": "Turing",
+          "CHIP": "TU102",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": "1",
+          "Total # of NVENC": "1",
+          "Max # of concurrent sessions": 2.0,
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": true,
+          "H.265 (HEVC) 4K Lossless": true,
+          "H.265 (HEVC) 8k": true,
+          "HEVC B Frame support": true,
+          "h264": true,
+          "hevc": true
+        },
+        "Quadro P500 / P520": {
+          "BOARD": "Quadro P500 / P520",
+          "FAMILY": "Pascal",
+          "CHIP": "GP108",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": 0,
+          "Total # of NVENC": 0,
+          "Max # of concurrent sessions": "0",
+          "H.264 (AVCHD) YUV 4:2:0": false,
+          "H.264 (AVCHD) YUV 4:4:4": false,
+          "H.264 (AVCHD) Lossless": false,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": false,
+          "hevc": false
+        },
+        "Quadro P400": {
+          "BOARD": "Quadro P400",
+          "FAMILY": "Pascal",
+          "CHIP": "GP107",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": 1,
+          "Total # of NVENC": 1,
+          "Max # of concurrent sessions": "2",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": true,
+          "H.265 (HEVC) 4K Lossless": true,
+          "H.265 (HEVC) 8k": true,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": true
+        },
+        "Quadro P600 / P1000": {
+          "BOARD": "Quadro P600 / P1000",
+          "FAMILY": "Pascal",
+          "CHIP": "GP107",
+          "Desktop/Mobile/Server": "D/M",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": 1,
+          "Total # of NVENC": 1,
+          "Max # of concurrent sessions": "2",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": true,
+          "H.265 (HEVC) 4K Lossless": true,
+          "H.265 (HEVC) 8k": true,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": true
+        },
+        "Quadro P2000": {
+          "BOARD": "Quadro P2000",
+          "FAMILY": "Pascal",
+          "CHIP": "GP107",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": 1,
+          "Total # of NVENC": 1,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": true,
+          "H.265 (HEVC) 4K Lossless": true,
+          "H.265 (HEVC) 8k": true,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": true
+        },
+        "Quadro P2000 / P2200": {
+          "BOARD": "Quadro P2000 / P2200",
+          "FAMILY": "Pascal",
+          "CHIP": "GP106",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": 1,
+          "Total # of NVENC": 1,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": true,
+          "H.265 (HEVC) 4K Lossless": true,
+          "H.265 (HEVC) 8k": true,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": true
+        },
+        "Quadro P3200 / P4200 / P5200": {
+          "BOARD": "Quadro P3200 / P4200 / P5200",
+          "FAMILY": "Pascal",
+          "CHIP": "GP104",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": 2,
+          "Total # of NVENC": 2,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": true,
+          "H.265 (HEVC) 4K Lossless": true,
+          "H.265 (HEVC) 8k": true,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": true
+        },
+        "Quadro P4000": {
+          "BOARD": "Quadro P4000",
+          "FAMILY": "Pascal",
+          "CHIP": "GP104",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": 1,
+          "Total # of NVENC": 1,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": true,
+          "H.265 (HEVC) 4K Lossless": true,
+          "H.265 (HEVC) 8k": true,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": true
+        },
+        "Quadro P5000": {
+          "BOARD": "Quadro P5000",
+          "FAMILY": "Pascal",
+          "CHIP": "GP104",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": 2,
+          "Total # of NVENC": 2,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": true,
+          "H.265 (HEVC) 4K Lossless": true,
+          "H.265 (HEVC) 8k": true,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": true
+        },
+        "Quadro P6000": {
+          "BOARD": "Quadro P6000",
+          "FAMILY": "Pascal",
+          "CHIP": "GP102",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": 2,
+          "Total # of NVENC": 2,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": true,
+          "H.265 (HEVC) 4K Lossless": true,
+          "H.265 (HEVC) 8k": true,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": true
+        },
+        "Quadro GP100": {
+          "BOARD": "Quadro GP100",
+          "FAMILY": "Pascal",
+          "CHIP": "GP100",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": 3,
+          "Total # of NVENC": 3,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": true,
+          "H.265 (HEVC) 4K Lossless": true,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": true
+        },
+        "Quadro GV100": {
+          "BOARD": "Quadro GV100",
+          "FAMILY": "Volta",
+          "CHIP": "GV100",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": 3,
+          "Total # of NVENC": 3,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": true,
+          "H.265 (HEVC) 4K Lossless": true,
+          "H.265 (HEVC) 8k": true,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": true
+        },
+        "Quadro T1000": {
+          "BOARD": "Quadro T1000",
+          "FAMILY": "Turing",
+          "CHIP": "TU117",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": 1,
+          "Total # of NVENC": 1,
+          "Max # of concurrent sessions": "2",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": true,
+          "H.265 (HEVC) 4K Lossless": true,
+          "H.265 (HEVC) 8k": true,
+          "HEVC B Frame support": true,
+          "h264": true,
+          "hevc": true
+        },
+        "Quadro T2000": {
+          "BOARD": "Quadro T2000",
+          "FAMILY": "Turing",
+          "CHIP": "TU117",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": 1,
+          "Total # of NVENC": 1,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": true,
+          "H.265 (HEVC) 4K Lossless": true,
+          "H.265 (HEVC) 8k": true,
+          "HEVC B Frame support": true,
+          "h264": true,
+          "hevc": true
+        },
+        "Quadro RTX 3000": {
+          "BOARD": "Quadro RTX 3000",
+          "FAMILY": "Turing",
+          "CHIP": "TU106",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": 1,
+          "Total # of NVENC": 1,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": true,
+          "H.265 (HEVC) 4K Lossless": true,
+          "H.265 (HEVC) 8k": true,
+          "HEVC B Frame support": true,
+          "h264": true,
+          "hevc": true
+        },
+        "Quadro RTX 5000/RTX 4000": {
+          "BOARD": "Quadro RTX 5000/RTX 4000",
+          "FAMILY": "Turing",
+          "CHIP": "TU104",
+          "Desktop/Mobile/Server": "D/M",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": 1,
+          "Total # of NVENC": 1,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": true,
+          "H.265 (HEVC) 4K Lossless": true,
+          "H.265 (HEVC) 8k": true,
+          "HEVC B Frame support": true,
+          "h264": true,
+          "hevc": true
+        },
+        "Quadro RTX 6000/RTX 8000": {
+          "BOARD": "Quadro RTX 6000/RTX 8000",
+          "FAMILY": "Turing",
+          "CHIP": "TU102",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": 1,
+          "Total # of NVENC": 1,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": true,
+          "H.265 (HEVC) 4K Lossless": true,
+          "H.265 (HEVC) 8k": true,
+          "HEVC B Frame support": true,
+          "h264": true,
+          "hevc": true
+        },
+        "Tesla P4 / P6": {
+          "BOARD": "Tesla P4 / P6",
+          "FAMILY": "Pascal",
+          "CHIP": "GP104",
+          "Desktop/Mobile/Server": "S",
+          "# OF CHIPS": 1.0,
+          "# OF NVENC/CHIP": "2",
+          "Total # of NVENC": "2",
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": true,
+          "H.265 (HEVC) 4K Lossless": true,
+          "H.265 (HEVC) 8k": true,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": true
+        },
+        "Tesla P40": {
+          "BOARD": "Tesla P40",
+          "FAMILY": "Pascal",
+          "CHIP": "GP102",
+          "# OF CHIPS": 1.0,
+          "# OF NVENC/CHIP": 2.0,
+          "Total # of NVENC": 2.0,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": true,
+          "H.265 (HEVC) 4K Lossless": true,
+          "H.265 (HEVC) 8k": true,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": true
+        },
+        "Tesla P100": {
+          "BOARD": "Tesla P100",
+          "FAMILY": "Pascal",
+          "CHIP": "GP100",
+          "# OF CHIPS": 1.0,
+          "# OF NVENC/CHIP": 3.0,
+          "Total # of NVENC": 3.0,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": true,
+          "H.265 (HEVC) 4K Lossless": true,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": true
+        },
+        "Tesla V100": {
+          "BOARD": "Tesla V100",
+          "FAMILY": "Volta",
+          "CHIP": "GV100",
+          "# OF CHIPS": 1.0,
+          "# OF NVENC/CHIP": 3.0,
+          "Total # of NVENC": 3.0,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": true,
+          "H.265 (HEVC) 4K Lossless": true,
+          "H.265 (HEVC) 8k": true,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": true
+        },
+        "Tesla T4": {
+          "BOARD": "Tesla T4",
+          "FAMILY": "Turing",
+          "CHIP": "TU104",
+          "# OF CHIPS": 1.0,
+          "# OF NVENC/CHIP": 1.0,
+          "Total # of NVENC": 1.0,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": true,
+          "H.265 (HEVC) 4K Lossless": true,
+          "H.265 (HEVC) 8k": true,
+          "HEVC B Frame support": true,
+          "h264": true,
+          "hevc": true
+        },
+        "GeForce 710A > 810A": {
+          "BOARD": "GeForce 710A > 810A",
+          "FAMILY": "Kepler",
+          "CHIP": "GK208",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": "1",
+          "Total # of NVENC": "1",
+          "Max # of concurrent sessions": 2.0,
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": false,
+          "H.264 (AVCHD) Lossless": false,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GeForce GT 723A / 740A": {
+          "BOARD": "GeForce GT 723A / 740A",
+          "FAMILY": "Kepler",
+          "CHIP": "GK208",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": "1",
+          "Total # of NVENC": "1",
+          "Max # of concurrent sessions": 2.0,
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": false,
+          "H.264 (AVCHD) Lossless": false,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GeForce GT 720M > 740M": {
+          "BOARD": "GeForce GT 720M > 740M",
+          "FAMILY": "Kepler",
+          "CHIP": "GK208",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": "1",
+          "Total # of NVENC": "1",
+          "Max # of concurrent sessions": 2.0,
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": false,
+          "H.264 (AVCHD) Lossless": false,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GeForce GT 630 / 635/ 640 / 710 / 730": {
+          "BOARD": "GeForce GT 630 / 635/ 640 / 710 / 730",
+          "FAMILY": "Kepler",
+          "CHIP": "GK208",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": "1",
+          "Total # of NVENC": "1",
+          "Max # of concurrent sessions": 2.0,
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": false,
+          "H.264 (AVCHD) Lossless": false,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GeForce 710A / 810M / 820M": {
+          "BOARD": "GeForce 710A / 810M / 820M",
+          "FAMILY": "Kepler",
+          "CHIP": "GK107",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": "1",
+          "Total # of NVENC": "1",
+          "Max # of concurrent sessions": 2.0,
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": false,
+          "H.264 (AVCHD) Lossless": false,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GeForce 640M > GT 755M / GTX 660M": {
+          "BOARD": "GeForce 640M > GT 755M / GTX 660M",
+          "FAMILY": "Kepler",
+          "CHIP": "GK107",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": "1",
+          "Total # of NVENC": "1",
+          "Max # of concurrent sessions": 2.0,
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": false,
+          "H.264 (AVCHD) Lossless": false,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GeForce GT 630 > 640 GeForce GTX 650 GeForce GT 740": {
+          "BOARD": "GeForce GT 630 > 640 GeForce GTX 650 GeForce GT 740",
+          "FAMILY": "Kepler",
+          "CHIP": "GK107",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": "1",
+          "Total # of NVENC": "1",
+          "Max # of concurrent sessions": 2.0,
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": false,
+          "H.264 (AVCHD) Lossless": false,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GeForce GTX 645 -660 Ti Boost GeForce GT 740": {
+          "BOARD": "GeForce GTX 645 -660 Ti Boost GeForce GT 740",
+          "FAMILY": "Kepler",
+          "CHIP": "GK106",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": "1",
+          "Total # of NVENC": "1",
+          "Max # of concurrent sessions": 2.0,
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": false,
+          "H.264 (AVCHD) Lossless": false,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GeForce GTX 660 - 690 GeForce GTX 760 - 770": {
+          "BOARD": "GeForce GTX 660 - 690 GeForce GTX 760 - 770",
+          "FAMILY": "Kepler",
+          "CHIP": "GK104",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": "1",
+          "Total # of NVENC": "1",
+          "Max # of concurrent sessions": 2.0,
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": false,
+          "H.264 (AVCHD) Lossless": false,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GeForce GT 780 - 780 Ti": {
+          "BOARD": "GeForce GT 780 - 780 Ti",
+          "FAMILY": "Kepler\u00a0(2nd\u00a0Gen)",
+          "CHIP": "GK110",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": "1",
+          "Total # of NVENC": "1",
+          "Max # of concurrent sessions": 2.0,
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": false,
+          "H.264 (AVCHD) Lossless": false,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GeForce GTX Titan / Titan Black": {
+          "BOARD": "GeForce GTX Titan / Titan Black",
+          "FAMILY": "Kepler\u00a0(2nd\u00a0Gen)",
+          "CHIP": "GK110",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": "1",
+          "Total # of NVENC": "1",
+          "Max # of concurrent sessions": 2.0,
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": false,
+          "H.264 (AVCHD) Lossless": false,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GeForce GTX Titan Z": {
+          "BOARD": "GeForce GTX Titan Z",
+          "FAMILY": "Kepler\u00a0(2nd\u00a0Gen)",
+          "CHIP": "GK110",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 2,
+          "# OF NVENC/CHIP": "1",
+          "Total # of NVENC": "2",
+          "Max # of concurrent sessions": 2.0,
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": false,
+          "H.264 (AVCHD) Lossless": false,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GeForce GTX 745 - 750 Ti": {
+          "BOARD": "GeForce GTX 745 - 750 Ti",
+          "FAMILY": "Maxwell\u00a0(1st\u00a0Gen)",
+          "CHIP": "GM107",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": "1",
+          "Total # of NVENC": "1",
+          "Max # of concurrent sessions": 2.0,
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GeForce 845M / 940M / 940MX / 945M": {
+          "BOARD": "GeForce 845M / 940M / 940MX / 945M",
+          "FAMILY": "Maxwell\u00a0(1st\u00a0Gen)",
+          "CHIP": "GM107",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": "1",
+          "Total # of NVENC": "1",
+          "Max # of concurrent sessions": 2.0,
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GeForce GTX 850A > 960A": {
+          "BOARD": "GeForce GTX 850A > 960A",
+          "FAMILY": "Maxwell\u00a0(1st\u00a0Gen)",
+          "CHIP": "GM107",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": "1",
+          "Total # of NVENC": "1",
+          "Max # of concurrent sessions": 2.0,
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GeForce GTX 850M > 960M": {
+          "BOARD": "GeForce GTX 850M > 960M",
+          "FAMILY": "Maxwell\u00a0(1st\u00a0Gen)",
+          "CHIP": "GM107",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": "1",
+          "Total # of NVENC": "1",
+          "Max # of concurrent sessions": 2.0,
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GeForce 830A > 945A": {
+          "BOARD": "GeForce 830A > 945A",
+          "FAMILY": "Maxwell\u00a0(1st\u00a0Gen)",
+          "CHIP": "GM108",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": "0",
+          "Total # of NVENC": "0",
+          "Max # of concurrent sessions": NaN,
+          "H.264 (AVCHD) YUV 4:2:0": false,
+          "H.264 (AVCHD) YUV 4:4:4": false,
+          "H.264 (AVCHD) Lossless": false,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": false,
+          "hevc": false
+        },
+        "GeForce 830M > 945M": {
+          "BOARD": "GeForce 830M > 945M",
+          "FAMILY": "Maxwell\u00a0(1st\u00a0Gen)",
+          "CHIP": "GM108",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": "0",
+          "Total # of NVENC": "0",
+          "Max # of concurrent sessions": NaN,
+          "H.264 (AVCHD) YUV 4:2:0": false,
+          "H.264 (AVCHD) YUV 4:4:4": false,
+          "H.264 (AVCHD) Lossless": false,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": false,
+          "hevc": false
+        },
+        "GeForce GTX 920MX - 940MX": {
+          "BOARD": "GeForce GTX 920MX - 940MX",
+          "FAMILY": "Maxwell\u00a0(1st\u00a0Gen)",
+          "CHIP": "GM108",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": "0",
+          "Total # of NVENC": "0",
+          "Max # of concurrent sessions": NaN,
+          "H.264 (AVCHD) YUV 4:2:0": false,
+          "H.264 (AVCHD) YUV 4:4:4": false,
+          "H.264 (AVCHD) Lossless": false,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": false,
+          "hevc": false
+        },
+        "GeForce MX110 / MX130": {
+          "BOARD": "GeForce MX110 / MX130",
+          "FAMILY": "Maxwell\u00a0(1st\u00a0Gen)",
+          "CHIP": "GM108",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": "0",
+          "Total # of NVENC": "0",
+          "Max # of concurrent sessions": NaN,
+          "H.264 (AVCHD) YUV 4:2:0": false,
+          "H.264 (AVCHD) YUV 4:4:4": false,
+          "H.264 (AVCHD) Lossless": false,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": false,
+          "hevc": false
+        },
+        "GeForce GTX 750 GeForce GTX 950 - 960": {
+          "BOARD": "GeForce GTX 750 GeForce GTX 950 - 960",
+          "FAMILY": "Maxwell\u00a0(2nd\u00a0Gen)",
+          "CHIP": "GM206",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": "1",
+          "Total # of NVENC": "1",
+          "Max # of concurrent sessions": 2.0,
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": true
+        },
+        "GeForce GTX 965M": {
+          "BOARD": "GeForce GTX 965M",
+          "FAMILY": "Maxwell\u00a0(2nd\u00a0Gen)",
+          "CHIP": "GM206",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": "1",
+          "Total # of NVENC": "1",
+          "Max # of concurrent sessions": 2.0,
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": true
+        },
+        "GeForce GTX 910M / 920M / 920A": {
+          "BOARD": "GeForce GTX 910M / 920M / 920A",
+          "FAMILY": "Maxwell\u00a0(2nd\u00a0Gen)",
+          "CHIP": "GM208B",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": "1",
+          "Total # of NVENC": "1",
+          "Max # of concurrent sessions": 2.0,
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": false,
+          "H.264 (AVCHD) Lossless": false,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GeForce GTX 965M > 980M / 980MX": {
+          "BOARD": "GeForce GTX 965M > 980M / 980MX",
+          "FAMILY": "Maxwell\u00a0(2nd\u00a0Gen)",
+          "CHIP": "GM204",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": "2",
+          "Total # of NVENC": "2",
+          "Max # of concurrent sessions": 2.0,
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": true
+        },
+        "GeForce GTX 960 Ti - 980": {
+          "BOARD": "GeForce GTX 960 Ti - 980",
+          "FAMILY": "Maxwell\u00a0(2nd\u00a0Gen)",
+          "CHIP": "GM204",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": "2",
+          "Total # of NVENC": "2",
+          "Max # of concurrent sessions": 2.0,
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": true
+        },
+        "GeForce GTX 980 Ti": {
+          "BOARD": "GeForce GTX 980 Ti",
+          "FAMILY": "Maxwell\u00a0(2nd\u00a0Gen)",
+          "CHIP": "GM200",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": "2",
+          "Total # of NVENC": "2",
+          "Max # of concurrent sessions": 2.0,
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": true
+        },
+        "GeForce GTX Titan X": {
+          "BOARD": "GeForce GTX Titan X",
+          "FAMILY": "Maxwell\u00a0(2nd\u00a0Gen)",
+          "CHIP": "GM200",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": "2",
+          "Total # of NVENC": "2",
+          "Max # of concurrent sessions": 2.0,
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": true
+        },
+        "GeForce MX150 > MX250": {
+          "BOARD": "GeForce MX150 > MX250",
+          "FAMILY": "Pascal",
+          "CHIP": "GP108",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": "0",
+          "Total # of NVENC": "0",
+          "Max # of concurrent sessions": 0.0,
+          "H.264 (AVCHD) YUV 4:2:0": false,
+          "H.264 (AVCHD) YUV 4:4:4": false,
+          "H.264 (AVCHD) Lossless": false,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": false,
+          "hevc": false
+        },
+        "Quadro K420 / K600": {
+          "BOARD": "Quadro K420 / K600",
+          "FAMILY": "Kepler",
+          "CHIP": "GK107",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": 1,
+          "Total # of NVENC": 1,
+          "Max # of concurrent sessions": "2",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": false,
+          "H.264 (AVCHD) Lossless": false,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": false
+        },
+        "Quadro K2000 / K2000D": {
+          "BOARD": "Quadro K2000 / K2000D",
+          "FAMILY": "Kepler",
+          "CHIP": "GK107",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": 1,
+          "Total # of NVENC": 1,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": false,
+          "H.264 (AVCHD) Lossless": false,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": false
+        },
+        "Quadro K2100 > K5000": {
+          "BOARD": "Quadro K2100 > K5000",
+          "FAMILY": "Kepler",
+          "CHIP": "GK106",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": 1,
+          "Total # of NVENC": 1,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": false,
+          "H.264 (AVCHD) Lossless": false,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": false
+        },
+        "Quadro K4000": {
+          "BOARD": "Quadro K4000",
+          "FAMILY": "Kepler",
+          "CHIP": "GK106",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": 1,
+          "Total # of NVENC": 1,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": false,
+          "H.264 (AVCHD) Lossless": false,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": false
+        },
+        "Quadro K100 > K2000 + K5100": {
+          "BOARD": "Quadro K100 > K2000 + K5100",
+          "FAMILY": "Kepler",
+          "CHIP": "GK104",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": 1,
+          "Total # of NVENC": 1,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": false,
+          "H.264 (AVCHD) Lossless": false,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": false
+        },
+        "Quadro K4200 / K5000": {
+          "BOARD": "Quadro K4200 / K5000",
+          "FAMILY": "Kepler",
+          "CHIP": "GK104",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": 1,
+          "Total # of NVENC": 1,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": false,
+          "H.264 (AVCHD) Lossless": false,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": false
+        },
+        "Quadro K5200 / K6000": {
+          "BOARD": "Quadro K5200 / K6000",
+          "FAMILY": "Kepler (2nd Gen)",
+          "CHIP": "GK110B",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": 1,
+          "Total # of NVENC": 1,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": false,
+          "H.264 (AVCHD) Lossless": false,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": false
+        },
+        "Quadro K620 / K1200": {
+          "BOARD": "Quadro K620 / K1200",
+          "FAMILY": "Maxwell (1st Gen)",
+          "CHIP": "GM107",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": 1,
+          "Total # of NVENC": 1,
+          "Max # of concurrent sessions": "2",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": false
+        },
+        "Quadro K2200": {
+          "BOARD": "Quadro K2200",
+          "FAMILY": "Maxwell (1st Gen)",
+          "CHIP": "GM107",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": 1,
+          "Total # of NVENC": 1,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": false
+        },
+        "Quadro M500 / M520": {
+          "BOARD": "Quadro M500 / M520",
+          "FAMILY": "Maxwell (1st Gen)",
+          "CHIP": "GM108",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": 0,
+          "Total # of NVENC": 0,
+          "Max # of concurrent sessions": NaN,
+          "H.264 (AVCHD) YUV 4:2:0": false,
+          "H.264 (AVCHD) YUV 4:4:4": false,
+          "H.264 (AVCHD) Lossless": false,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": false,
+          "hevc": false
+        },
+        "Quadro M600 / M620": {
+          "BOARD": "Quadro M600 / M620",
+          "FAMILY": "Maxwell (1st Gen)",
+          "CHIP": "GM107",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": 1,
+          "Total # of NVENC": 1,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": false
+        },
+        "Quadro M1000 / M1200 / M2000": {
+          "BOARD": "Quadro M1000 / M1200 / M2000",
+          "FAMILY": "Maxwell (1st Gen)",
+          "CHIP": "GM107",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": 1,
+          "Total # of NVENC": 1,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": false
+        },
+        "Quadro M2000": {
+          "BOARD": "Quadro M2000",
+          "FAMILY": "Maxwell (GM206)",
+          "CHIP": "GM206",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": 1,
+          "Total # of NVENC": 1,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": true
+        },
+        "Quadro M2200": {
+          "BOARD": "Quadro M2200",
+          "FAMILY": "Maxwell (GM206)",
+          "CHIP": "GM206",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": 1,
+          "Total # of NVENC": 1,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": true
+        },
+        "Quadro M3000 / M4000 / M5500": {
+          "BOARD": "Quadro M3000 / M4000 / M5500",
+          "FAMILY": "Maxwell (2nd Gen)",
+          "CHIP": "GM204",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": 2,
+          "Total # of NVENC": 2,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": true
+        },
+        "Quadro M4000 / M5000": {
+          "BOARD": "Quadro M4000 / M5000",
+          "FAMILY": "Maxwell (2nd Gen)",
+          "CHIP": "GM204",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": 2,
+          "Total # of NVENC": 2,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": true
+        },
+        "Quadro M6000": {
+          "BOARD": "Quadro M6000",
+          "FAMILY": "Maxwell\u00a0(2nd\u00a0Gen)",
+          "CHIP": "GM200",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVENC/CHIP": 2,
+          "Total # of NVENC": 2,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": true
+        },
+        "GRID K1": {
+          "BOARD": "GRID K1",
+          "FAMILY": "Kepler",
+          "CHIP": "GK107",
+          "# OF CHIPS": 4.0,
+          "# OF NVENC/CHIP": 1.0,
+          "Total # of NVENC": 4.0,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": false,
+          "H.264 (AVCHD) Lossless": false,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GRID K2": {
+          "BOARD": "GRID K2",
+          "FAMILY": "Kepler",
+          "CHIP": "GK104",
+          "# OF CHIPS": 2.0,
+          "# OF NVENC/CHIP": 1.0,
+          "Total # of NVENC": 2.0,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": false,
+          "H.264 (AVCHD) Lossless": false,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GRID K340": {
+          "BOARD": "GRID K340",
+          "FAMILY": "Kepler",
+          "CHIP": "GK107",
+          "# OF CHIPS": 4.0,
+          "# OF NVENC/CHIP": 1.0,
+          "Total # of NVENC": 4.0,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": false,
+          "H.264 (AVCHD) Lossless": false,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GRID K520": {
+          "BOARD": "GRID K520",
+          "FAMILY": "Kepler",
+          "CHIP": "GK104",
+          "# OF CHIPS": 2.0,
+          "# OF NVENC/CHIP": 1.0,
+          "Total # of NVENC": 2.0,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": false,
+          "H.264 (AVCHD) Lossless": false,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": false
+        },
+        "Tesla K10": {
+          "BOARD": "Tesla K10",
+          "FAMILY": "Kepler",
+          "CHIP": "GK104",
+          "# OF CHIPS": 2.0,
+          "# OF NVENC/CHIP": 1.0,
+          "Total # of NVENC": 2.0,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": false,
+          "H.264 (AVCHD) Lossless": false,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": false
+        },
+        "Tesla K20X": {
+          "BOARD": "Tesla K20X",
+          "FAMILY": "Kepler",
+          "CHIP": "GK110",
+          "# OF CHIPS": 1.0,
+          "# OF NVENC/CHIP": 1.0,
+          "Total # of NVENC": 1.0,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": false,
+          "H.264 (AVCHD) Lossless": false,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": false
+        },
+        "Tesla K40": {
+          "BOARD": "Tesla K40",
+          "FAMILY": "Kepler",
+          "CHIP": "GK110B",
+          "# OF CHIPS": 1.0,
+          "# OF NVENC/CHIP": 1.0,
+          "Total # of NVENC": 1.0,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": false,
+          "H.264 (AVCHD) Lossless": false,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": false
+        },
+        "Tesla K80": {
+          "BOARD": "Tesla K80",
+          "FAMILY": "Kepler (2nd Gen)",
+          "CHIP": "GK210",
+          "# OF CHIPS": 2.0,
+          "# OF NVENC/CHIP": 1.0,
+          "Total # of NVENC": 2.0,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": false,
+          "H.264 (AVCHD) Lossless": false,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": false
+        },
+        "Tesla M10": {
+          "BOARD": "Tesla M10",
+          "FAMILY": "Maxwell (1st Gen)",
+          "CHIP": "GM107",
+          "# OF CHIPS": 4.0,
+          "# OF NVENC/CHIP": 1.0,
+          "Total # of NVENC": 4.0,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": false,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": false
+        },
+        "Tesla M4": {
+          "BOARD": "Tesla M4",
+          "FAMILY": "Maxwell (GM206)",
+          "CHIP": "GM206",
+          "# OF CHIPS": 1.0,
+          "# OF NVENC/CHIP": 1.0,
+          "Total # of NVENC": 1.0,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": true
+        },
+        "Tesla M40": {
+          "BOARD": "Tesla M40",
+          "FAMILY": "Maxwell\u00a0(2nd\u00a0Gen)",
+          "CHIP": "GM200",
+          "# OF CHIPS": 1.0,
+          "# OF NVENC/CHIP": 2.0,
+          "Total # of NVENC": 2.0,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": true
+        },
+        "Tesla M6": {
+          "BOARD": "Tesla M6",
+          "FAMILY": "Maxwell\u00a0(2nd\u00a0Gen)",
+          "CHIP": "GM204",
+          "# OF CHIPS": 1.0,
+          "# OF NVENC/CHIP": 2.0,
+          "Total # of NVENC": 2.0,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": true
+        },
+        "Tesla M60": {
+          "BOARD": "Tesla M60",
+          "FAMILY": "Maxwell\u00a0(2nd\u00a0Gen)",
+          "CHIP": "GM204",
+          "# OF CHIPS": 2.0,
+          "# OF NVENC/CHIP": 2.0,
+          "Total # of NVENC": 4.0,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": false,
+          "H.265 (HEVC) 4K Lossless": false,
+          "H.265 (HEVC) 8k": false,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": true
+        },
+        "Tesla P4": {
+          "BOARD": "Tesla P4",
+          "FAMILY": "Pascal",
+          "CHIP": "GP104",
+          "# OF CHIPS": 1.0,
+          "# OF NVENC/CHIP": 2.0,
+          "Total # of NVENC": 2.0,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": true,
+          "H.265 (HEVC) 4K Lossless": true,
+          "H.265 (HEVC) 8k": true,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": true
+        },
+        "Tesla P6": {
+          "BOARD": "Tesla P6",
+          "FAMILY": "Pascal",
+          "CHIP": "GP104",
+          "# OF CHIPS": 1.0,
+          "# OF NVENC/CHIP": 2.0,
+          "Total # of NVENC": 2.0,
+          "Max # of concurrent sessions": "Unrestricted",
+          "H.264 (AVCHD) YUV 4:2:0": true,
+          "H.264 (AVCHD) YUV 4:4:4": true,
+          "H.264 (AVCHD) Lossless": true,
+          "H.265 (HEVC) 4K YUV 4:2:0": true,
+          "H.265 (HEVC) 4K YUV 4:4:4": true,
+          "H.265 (HEVC) 4K Lossless": true,
+          "H.265 (HEVC) 8k": true,
+          "HEVC B Frame support": false,
+          "h264": true,
+          "hevc": true
+        }
       }
     },
-    "boards": {
-      "GeForce GT 1030": {
-        "BOARD": "GeForce GT 1030",
-        "FAMILY": "Pascal",
-        "CHIP": "GP108",
-        "Desktop/Mobile/Server": "D",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": "0",
-        "Total # of NVENC": "0",
-        "Max # of concurrent sessions": 0.0,
-        "H.264 (AVCHD) YUV 4:2:0": false,
-        "H.264 (AVCHD) YUV 4:4:4": false,
-        "H.264 (AVCHD) Lossless": false,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": false,
-        "hevc": false
-      },
-      "GeForce GTX 1050 / 1050 Ti": {
-        "BOARD": "GeForce GTX 1050 / 1050 Ti",
-        "FAMILY": "Pascal",
-        "CHIP": "GP106",
-        "Desktop/Mobile/Server": "D/M",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": "1",
-        "Total # of NVENC": "1",
-        "Max # of concurrent sessions": 2.0,
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": true,
-        "H.265 (HEVC) 4K Lossless": true,
-        "H.265 (HEVC) 8k": true,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": true
-      },
-      "GeForce GTX 1060": {
-        "BOARD": "GeForce GTX 1060",
-        "FAMILY": "Pascal",
-        "CHIP": "GP104",
-        "Desktop/Mobile/Server": "D/M",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": "1",
-        "Total # of NVENC": "1",
-        "Max # of concurrent sessions": 2.0,
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": true,
-        "H.265 (HEVC) 4K Lossless": true,
-        "H.265 (HEVC) 8k": true,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": true
-      },
-      "GeForce GTX 1070M / 1080M": {
-        "BOARD": "GeForce GTX 1070M / 1080M",
-        "FAMILY": "Pascal",
-        "CHIP": "GP104B",
-        "Desktop/Mobile/Server": "M",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": "2",
-        "Total # of NVENC": "2",
-        "Max # of concurrent sessions": 2.0,
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": true,
-        "H.265 (HEVC) 4K Lossless": true,
-        "H.265 (HEVC) 8k": true,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": true
-      },
-      "GeForce GTX 1070 / 1070Ti": {
-        "BOARD": "GeForce GTX 1070 / 1070Ti",
-        "FAMILY": "Pascal",
-        "CHIP": "GP104",
-        "Desktop/Mobile/Server": "D/M",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": "2",
-        "Total # of NVENC": "2",
-        "Max # of concurrent sessions": 2.0,
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": true,
-        "H.265 (HEVC) 4K Lossless": true,
-        "H.265 (HEVC) 8k": true,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": true
-      },
-      "GeForce GTX 1080": {
-        "BOARD": "GeForce GTX 1080",
-        "FAMILY": "Pascal",
-        "CHIP": "GP104",
-        "Desktop/Mobile/Server": "D/M",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": "2",
-        "Total # of NVENC": "2",
-        "Max # of concurrent sessions": 2.0,
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": true,
-        "H.265 (HEVC) 4K Lossless": true,
-        "H.265 (HEVC) 8k": true,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": true
-      },
-      "GeForce GTX 1080 Ti": {
-        "BOARD": "GeForce GTX 1080 Ti",
-        "FAMILY": "Pascal",
-        "CHIP": "GP102",
-        "Desktop/Mobile/Server": "D",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": "2",
-        "Total # of NVENC": "2",
-        "Max # of concurrent sessions": 2.0,
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": true,
-        "H.265 (HEVC) 4K Lossless": true,
-        "H.265 (HEVC) 8k": true,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": true
-      },
-      "GeForce GTX Titan X / Titan Xp": {
-        "BOARD": "GeForce GTX Titan X / Titan Xp",
-        "FAMILY": "Pascal",
-        "CHIP": "GP102",
-        "Desktop/Mobile/Server": "D",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": "2",
-        "Total # of NVENC": "2",
-        "Max # of concurrent sessions": 2.0,
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": true,
-        "H.265 (HEVC) 4K Lossless": true,
-        "H.265 (HEVC) 8k": true,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": true
-      },
-      "Titan V": {
-        "BOARD": "Titan V",
-        "FAMILY": "Volta",
-        "CHIP": "GV100",
-        "Desktop/Mobile/Server": "D",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": "3",
-        "Total # of NVENC": "3",
-        "Max # of concurrent sessions": 2.0,
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": true,
-        "H.265 (HEVC) 4K Lossless": true,
-        "H.265 (HEVC) 8k": true,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": true
-      },
-      "GeForce GTX 1650": {
-        "BOARD": "GeForce GTX 1650",
-        "FAMILY": "Turing*",
-        "CHIP": "TU117",
-        "Desktop/Mobile/Server": "D/M",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": "1*",
-        "Total # of NVENC": "1*",
-        "Max # of concurrent sessions": 2.0,
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": true,
-        "H.265 (HEVC) 4K Lossless": true,
-        "H.265 (HEVC) 8k": true,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": true
-      },
-      "GeForce GTX 1660 Ti / 1660": {
-        "BOARD": "GeForce GTX 1660 Ti / 1660",
-        "FAMILY": "Turing",
-        "CHIP": "TU116",
-        "Desktop/Mobile/Server": "D/M",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": "1",
-        "Total # of NVENC": "1",
-        "Max # of concurrent sessions": 2.0,
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": true,
-        "H.265 (HEVC) 4K Lossless": true,
-        "H.265 (HEVC) 8k": true,
-        "HEVC B Frame support": true,
-        "h264": true,
-        "hevc": true
-      },
-      "GeForce RTX 2060 / 2070": {
-        "BOARD": "GeForce RTX 2060 / 2070",
-        "FAMILY": "Turing",
-        "CHIP": "TU106",
-        "Desktop/Mobile/Server": "D/M",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": "1",
-        "Total # of NVENC": "1",
-        "Max # of concurrent sessions": 2.0,
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": true,
-        "H.265 (HEVC) 4K Lossless": true,
-        "H.265 (HEVC) 8k": true,
-        "HEVC B Frame support": true,
-        "h264": true,
-        "hevc": true
-      },
-      "GeForce RTX 2080": {
-        "BOARD": "GeForce RTX 2080",
-        "FAMILY": "Turing",
-        "CHIP": "TU104",
-        "Desktop/Mobile/Server": "D/M",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": "1",
-        "Total # of NVENC": "1",
-        "Max # of concurrent sessions": 2.0,
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": true,
-        "H.265 (HEVC) 4K Lossless": true,
-        "H.265 (HEVC) 8k": true,
-        "HEVC B Frame support": true,
-        "h264": true,
-        "hevc": true
-      },
-      "GeForce RTX 2080 Ti": {
-        "BOARD": "GeForce RTX 2080 Ti",
-        "FAMILY": "Turing",
-        "CHIP": "TU102",
-        "Desktop/Mobile/Server": "D",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": "1",
-        "Total # of NVENC": "1",
-        "Max # of concurrent sessions": 2.0,
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": true,
-        "H.265 (HEVC) 4K Lossless": true,
-        "H.265 (HEVC) 8k": true,
-        "HEVC B Frame support": true,
-        "h264": true,
-        "hevc": true
-      },
-      "Titan RTX": {
-        "BOARD": "Titan RTX",
-        "FAMILY": "Turing",
-        "CHIP": "TU102",
-        "Desktop/Mobile/Server": "D",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": "1",
-        "Total # of NVENC": "1",
-        "Max # of concurrent sessions": 2.0,
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": true,
-        "H.265 (HEVC) 4K Lossless": true,
-        "H.265 (HEVC) 8k": true,
-        "HEVC B Frame support": true,
-        "h264": true,
-        "hevc": true
-      },
-      "Quadro P500 / P520": {
-        "BOARD": "Quadro P500 / P520",
-        "FAMILY": "Pascal",
-        "CHIP": "GP108",
-        "Desktop/Mobile/Server": "M",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": 0,
-        "Total # of NVENC": 0,
-        "Max # of concurrent sessions": "0",
-        "H.264 (AVCHD) YUV 4:2:0": false,
-        "H.264 (AVCHD) YUV 4:4:4": false,
-        "H.264 (AVCHD) Lossless": false,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": false,
-        "hevc": false
-      },
-      "Quadro P400": {
-        "BOARD": "Quadro P400",
-        "FAMILY": "Pascal",
-        "CHIP": "GP107",
-        "Desktop/Mobile/Server": "D",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": 1,
-        "Total # of NVENC": 1,
-        "Max # of concurrent sessions": "2",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": true,
-        "H.265 (HEVC) 4K Lossless": true,
-        "H.265 (HEVC) 8k": true,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": true
-      },
-      "Quadro P600 / P1000": {
-        "BOARD": "Quadro P600 / P1000",
-        "FAMILY": "Pascal",
-        "CHIP": "GP107",
-        "Desktop/Mobile/Server": "D/M",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": 1,
-        "Total # of NVENC": 1,
-        "Max # of concurrent sessions": "2",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": true,
-        "H.265 (HEVC) 4K Lossless": true,
-        "H.265 (HEVC) 8k": true,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": true
-      },
-      "Quadro P2000": {
-        "BOARD": "Quadro P2000",
-        "FAMILY": "Pascal",
-        "CHIP": "GP107",
-        "Desktop/Mobile/Server": "M",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": 1,
-        "Total # of NVENC": 1,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": true,
-        "H.265 (HEVC) 4K Lossless": true,
-        "H.265 (HEVC) 8k": true,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": true
-      },
-      "Quadro P2000 / P2200": {
-        "BOARD": "Quadro P2000 / P2200",
-        "FAMILY": "Pascal",
-        "CHIP": "GP106",
-        "Desktop/Mobile/Server": "D",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": 1,
-        "Total # of NVENC": 1,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": true,
-        "H.265 (HEVC) 4K Lossless": true,
-        "H.265 (HEVC) 8k": true,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": true
-      },
-      "Quadro P3200 / P4200 / P5200": {
-        "BOARD": "Quadro P3200 / P4200 / P5200",
-        "FAMILY": "Pascal",
-        "CHIP": "GP104",
-        "Desktop/Mobile/Server": "M",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": 2,
-        "Total # of NVENC": 2,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": true,
-        "H.265 (HEVC) 4K Lossless": true,
-        "H.265 (HEVC) 8k": true,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": true
-      },
-      "Quadro P4000": {
-        "BOARD": "Quadro P4000",
-        "FAMILY": "Pascal",
-        "CHIP": "GP104",
-        "Desktop/Mobile/Server": "D",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": 1,
-        "Total # of NVENC": 1,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": true,
-        "H.265 (HEVC) 4K Lossless": true,
-        "H.265 (HEVC) 8k": true,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": true
-      },
-      "Quadro P5000": {
-        "BOARD": "Quadro P5000",
-        "FAMILY": "Pascal",
-        "CHIP": "GP104",
-        "Desktop/Mobile/Server": "D",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": 2,
-        "Total # of NVENC": 2,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": true,
-        "H.265 (HEVC) 4K Lossless": true,
-        "H.265 (HEVC) 8k": true,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": true
-      },
-      "Quadro P6000": {
-        "BOARD": "Quadro P6000",
-        "FAMILY": "Pascal",
-        "CHIP": "GP102",
-        "Desktop/Mobile/Server": "D",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": 2,
-        "Total # of NVENC": 2,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": true,
-        "H.265 (HEVC) 4K Lossless": true,
-        "H.265 (HEVC) 8k": true,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": true
-      },
-      "Quadro GP100": {
-        "BOARD": "Quadro GP100",
-        "FAMILY": "Pascal",
-        "CHIP": "GP100",
-        "Desktop/Mobile/Server": "D",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": 3,
-        "Total # of NVENC": 3,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": true,
-        "H.265 (HEVC) 4K Lossless": true,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": true
-      },
-      "Quadro GV100": {
-        "BOARD": "Quadro GV100",
-        "FAMILY": "Volta",
-        "CHIP": "GV100",
-        "Desktop/Mobile/Server": "D",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": 3,
-        "Total # of NVENC": 3,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": true,
-        "H.265 (HEVC) 4K Lossless": true,
-        "H.265 (HEVC) 8k": true,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": true
-      },
-      "Quadro T1000": {
-        "BOARD": "Quadro T1000",
-        "FAMILY": "Turing",
-        "CHIP": "TU117",
-        "Desktop/Mobile/Server": "M",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": 1,
-        "Total # of NVENC": 1,
-        "Max # of concurrent sessions": "2",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": true,
-        "H.265 (HEVC) 4K Lossless": true,
-        "H.265 (HEVC) 8k": true,
-        "HEVC B Frame support": true,
-        "h264": true,
-        "hevc": true
-      },
-      "Quadro T2000": {
-        "BOARD": "Quadro T2000",
-        "FAMILY": "Turing",
-        "CHIP": "TU117",
-        "Desktop/Mobile/Server": "M",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": 1,
-        "Total # of NVENC": 1,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": true,
-        "H.265 (HEVC) 4K Lossless": true,
-        "H.265 (HEVC) 8k": true,
-        "HEVC B Frame support": true,
-        "h264": true,
-        "hevc": true
-      },
-      "Quadro RTX 3000": {
-        "BOARD": "Quadro RTX 3000",
-        "FAMILY": "Turing",
-        "CHIP": "TU106",
-        "Desktop/Mobile/Server": "M",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": 1,
-        "Total # of NVENC": 1,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": true,
-        "H.265 (HEVC) 4K Lossless": true,
-        "H.265 (HEVC) 8k": true,
-        "HEVC B Frame support": true,
-        "h264": true,
-        "hevc": true
-      },
-      "Quadro RTX 5000/RTX 4000": {
-        "BOARD": "Quadro RTX 5000/RTX 4000",
-        "FAMILY": "Turing",
-        "CHIP": "TU104",
-        "Desktop/Mobile/Server": "D/M",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": 1,
-        "Total # of NVENC": 1,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": true,
-        "H.265 (HEVC) 4K Lossless": true,
-        "H.265 (HEVC) 8k": true,
-        "HEVC B Frame support": true,
-        "h264": true,
-        "hevc": true
-      },
-      "Quadro RTX 6000/RTX 8000": {
-        "BOARD": "Quadro RTX 6000/RTX 8000",
-        "FAMILY": "Turing",
-        "CHIP": "TU102",
-        "Desktop/Mobile/Server": "D",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": 1,
-        "Total # of NVENC": 1,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": true,
-        "H.265 (HEVC) 4K Lossless": true,
-        "H.265 (HEVC) 8k": true,
-        "HEVC B Frame support": true,
-        "h264": true,
-        "hevc": true
-      },
-      "Tesla P4 / P6": {
-        "BOARD": "Tesla P4 / P6",
-        "FAMILY": "Pascal",
-        "CHIP": "GP104",
-        "Desktop/Mobile/Server": "S",
-        "# OF CHIPS": 1.0,
-        "# OF NVENC/CHIP": "2",
-        "Total # of NVENC": "2",
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": true,
-        "H.265 (HEVC) 4K Lossless": true,
-        "H.265 (HEVC) 8k": true,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": true
-      },
-      "Tesla P40": {
-        "BOARD": "Tesla P40",
-        "FAMILY": "Pascal",
-        "CHIP": "GP102",
-        "# OF CHIPS": 1.0,
-        "# OF NVENC/CHIP": 2.0,
-        "Total # of NVENC": 2.0,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": true,
-        "H.265 (HEVC) 4K Lossless": true,
-        "H.265 (HEVC) 8k": true,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": true
-      },
-      "Tesla P100": {
-        "BOARD": "Tesla P100",
-        "FAMILY": "Pascal",
-        "CHIP": "GP100",
-        "# OF CHIPS": 1.0,
-        "# OF NVENC/CHIP": 3.0,
-        "Total # of NVENC": 3.0,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": true,
-        "H.265 (HEVC) 4K Lossless": true,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": true
-      },
-      "Tesla V100": {
-        "BOARD": "Tesla V100",
-        "FAMILY": "Volta",
-        "CHIP": "GV100",
-        "# OF CHIPS": 1.0,
-        "# OF NVENC/CHIP": 3.0,
-        "Total # of NVENC": 3.0,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": true,
-        "H.265 (HEVC) 4K Lossless": true,
-        "H.265 (HEVC) 8k": true,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": true
-      },
-      "Tesla T4": {
-        "BOARD": "Tesla T4",
-        "FAMILY": "Turing",
-        "CHIP": "TU104",
-        "# OF CHIPS": 1.0,
-        "# OF NVENC/CHIP": 1.0,
-        "Total # of NVENC": 1.0,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": true,
-        "H.265 (HEVC) 4K Lossless": true,
-        "H.265 (HEVC) 8k": true,
-        "HEVC B Frame support": true,
-        "h264": true,
-        "hevc": true
-      },
-      "GeForce 710A > 810A": {
-        "BOARD": "GeForce 710A > 810A",
-        "FAMILY": "Kepler",
-        "CHIP": "GK208",
-        "Desktop/Mobile/Server": "M",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": "1",
-        "Total # of NVENC": "1",
-        "Max # of concurrent sessions": 2.0,
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": false,
-        "H.264 (AVCHD) Lossless": false,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": false
-      },
-      "GeForce GT 723A / 740A": {
-        "BOARD": "GeForce GT 723A / 740A",
-        "FAMILY": "Kepler",
-        "CHIP": "GK208",
-        "Desktop/Mobile/Server": "M",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": "1",
-        "Total # of NVENC": "1",
-        "Max # of concurrent sessions": 2.0,
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": false,
-        "H.264 (AVCHD) Lossless": false,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": false
-      },
-      "GeForce GT 720M > 740M": {
-        "BOARD": "GeForce GT 720M > 740M",
-        "FAMILY": "Kepler",
-        "CHIP": "GK208",
-        "Desktop/Mobile/Server": "M",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": "1",
-        "Total # of NVENC": "1",
-        "Max # of concurrent sessions": 2.0,
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": false,
-        "H.264 (AVCHD) Lossless": false,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": false
-      },
-      "GeForce GT 630 / 635/ 640 / 710 / 730": {
-        "BOARD": "GeForce GT 630 / 635/ 640 / 710 / 730",
-        "FAMILY": "Kepler",
-        "CHIP": "GK208",
-        "Desktop/Mobile/Server": "D",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": "1",
-        "Total # of NVENC": "1",
-        "Max # of concurrent sessions": 2.0,
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": false,
-        "H.264 (AVCHD) Lossless": false,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": false
-      },
-      "GeForce 710A / 810M / 820M": {
-        "BOARD": "GeForce 710A / 810M / 820M",
-        "FAMILY": "Kepler",
-        "CHIP": "GK107",
-        "Desktop/Mobile/Server": "M",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": "1",
-        "Total # of NVENC": "1",
-        "Max # of concurrent sessions": 2.0,
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": false,
-        "H.264 (AVCHD) Lossless": false,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": false
-      },
-      "GeForce 640M > GT 755M / GTX 660M": {
-        "BOARD": "GeForce 640M > GT 755M / GTX 660M",
-        "FAMILY": "Kepler",
-        "CHIP": "GK107",
-        "Desktop/Mobile/Server": "M",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": "1",
-        "Total # of NVENC": "1",
-        "Max # of concurrent sessions": 2.0,
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": false,
-        "H.264 (AVCHD) Lossless": false,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": false
-      },
-      "GeForce GT 630 > 640 GeForce GTX 650 GeForce GT 740": {
-        "BOARD": "GeForce GT 630 > 640 GeForce GTX 650 GeForce GT 740",
-        "FAMILY": "Kepler",
-        "CHIP": "GK107",
-        "Desktop/Mobile/Server": "D",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": "1",
-        "Total # of NVENC": "1",
-        "Max # of concurrent sessions": 2.0,
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": false,
-        "H.264 (AVCHD) Lossless": false,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": false
-      },
-      "GeForce GTX 645 -660 Ti Boost GeForce GT 740": {
-        "BOARD": "GeForce GTX 645 -660 Ti Boost GeForce GT 740",
-        "FAMILY": "Kepler",
-        "CHIP": "GK106",
-        "Desktop/Mobile/Server": "D",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": "1",
-        "Total # of NVENC": "1",
-        "Max # of concurrent sessions": 2.0,
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": false,
-        "H.264 (AVCHD) Lossless": false,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": false
-      },
-      "GeForce GTX 660 - 690 GeForce GTX 760 - 770": {
-        "BOARD": "GeForce GTX 660 - 690 GeForce GTX 760 - 770",
-        "FAMILY": "Kepler",
-        "CHIP": "GK104",
-        "Desktop/Mobile/Server": "D",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": "1",
-        "Total # of NVENC": "1",
-        "Max # of concurrent sessions": 2.0,
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": false,
-        "H.264 (AVCHD) Lossless": false,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": false
-      },
-      "GeForce GT 780 - 780 Ti": {
-        "BOARD": "GeForce GT 780 - 780 Ti",
-        "FAMILY": "Kepler\u00a0(2nd\u00a0Gen)",
-        "CHIP": "GK110",
-        "Desktop/Mobile/Server": "D",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": "1",
-        "Total # of NVENC": "1",
-        "Max # of concurrent sessions": 2.0,
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": false,
-        "H.264 (AVCHD) Lossless": false,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": false
-      },
-      "GeForce GTX Titan / Titan Black": {
-        "BOARD": "GeForce GTX Titan / Titan Black",
-        "FAMILY": "Kepler\u00a0(2nd\u00a0Gen)",
-        "CHIP": "GK110",
-        "Desktop/Mobile/Server": "D",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": "1",
-        "Total # of NVENC": "1",
-        "Max # of concurrent sessions": 2.0,
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": false,
-        "H.264 (AVCHD) Lossless": false,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": false
-      },
-      "GeForce GTX Titan Z": {
-        "BOARD": "GeForce GTX Titan Z",
-        "FAMILY": "Kepler\u00a0(2nd\u00a0Gen)",
-        "CHIP": "GK110",
-        "Desktop/Mobile/Server": "D",
-        "# OF CHIPS": 2,
-        "# OF NVENC/CHIP": "1",
-        "Total # of NVENC": "2",
-        "Max # of concurrent sessions": 2.0,
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": false,
-        "H.264 (AVCHD) Lossless": false,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": false
-      },
-      "GeForce GTX 745 - 750 Ti": {
-        "BOARD": "GeForce GTX 745 - 750 Ti",
-        "FAMILY": "Maxwell\u00a0(1st\u00a0Gen)",
-        "CHIP": "GM107",
-        "Desktop/Mobile/Server": "D",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": "1",
-        "Total # of NVENC": "1",
-        "Max # of concurrent sessions": 2.0,
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": false
-      },
-      "GeForce 845M / 940M / 940MX / 945M": {
-        "BOARD": "GeForce 845M / 940M / 940MX / 945M",
-        "FAMILY": "Maxwell\u00a0(1st\u00a0Gen)",
-        "CHIP": "GM107",
-        "Desktop/Mobile/Server": "M",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": "1",
-        "Total # of NVENC": "1",
-        "Max # of concurrent sessions": 2.0,
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": false
-      },
-      "GeForce GTX 850A > 960A": {
-        "BOARD": "GeForce GTX 850A > 960A",
-        "FAMILY": "Maxwell\u00a0(1st\u00a0Gen)",
-        "CHIP": "GM107",
-        "Desktop/Mobile/Server": "M",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": "1",
-        "Total # of NVENC": "1",
-        "Max # of concurrent sessions": 2.0,
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": false
-      },
-      "GeForce GTX 850M > 960M": {
-        "BOARD": "GeForce GTX 850M > 960M",
-        "FAMILY": "Maxwell\u00a0(1st\u00a0Gen)",
-        "CHIP": "GM107",
-        "Desktop/Mobile/Server": "M",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": "1",
-        "Total # of NVENC": "1",
-        "Max # of concurrent sessions": 2.0,
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": false
-      },
-      "GeForce 830A > 945A": {
-        "BOARD": "GeForce 830A > 945A",
-        "FAMILY": "Maxwell\u00a0(1st\u00a0Gen)",
-        "CHIP": "GM108",
-        "Desktop/Mobile/Server": "M",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": "0",
-        "Total # of NVENC": "0",
-        "Max # of concurrent sessions": NaN,
-        "H.264 (AVCHD) YUV 4:2:0": false,
-        "H.264 (AVCHD) YUV 4:4:4": false,
-        "H.264 (AVCHD) Lossless": false,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": false,
-        "hevc": false
-      },
-      "GeForce 830M > 945M": {
-        "BOARD": "GeForce 830M > 945M",
-        "FAMILY": "Maxwell\u00a0(1st\u00a0Gen)",
-        "CHIP": "GM108",
-        "Desktop/Mobile/Server": "M",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": "0",
-        "Total # of NVENC": "0",
-        "Max # of concurrent sessions": NaN,
-        "H.264 (AVCHD) YUV 4:2:0": false,
-        "H.264 (AVCHD) YUV 4:4:4": false,
-        "H.264 (AVCHD) Lossless": false,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": false,
-        "hevc": false
-      },
-      "GeForce GTX 920MX - 940MX": {
-        "BOARD": "GeForce GTX 920MX - 940MX",
-        "FAMILY": "Maxwell\u00a0(1st\u00a0Gen)",
-        "CHIP": "GM108",
-        "Desktop/Mobile/Server": "M",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": "0",
-        "Total # of NVENC": "0",
-        "Max # of concurrent sessions": NaN,
-        "H.264 (AVCHD) YUV 4:2:0": false,
-        "H.264 (AVCHD) YUV 4:4:4": false,
-        "H.264 (AVCHD) Lossless": false,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": false,
-        "hevc": false
-      },
-      "GeForce MX110 / MX130": {
-        "BOARD": "GeForce MX110 / MX130",
-        "FAMILY": "Maxwell\u00a0(1st\u00a0Gen)",
-        "CHIP": "GM108",
-        "Desktop/Mobile/Server": "M",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": "0",
-        "Total # of NVENC": "0",
-        "Max # of concurrent sessions": NaN,
-        "H.264 (AVCHD) YUV 4:2:0": false,
-        "H.264 (AVCHD) YUV 4:4:4": false,
-        "H.264 (AVCHD) Lossless": false,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": false,
-        "hevc": false
-      },
-      "GeForce GTX 750 GeForce GTX 950 - 960": {
-        "BOARD": "GeForce GTX 750 GeForce GTX 950 - 960",
-        "FAMILY": "Maxwell\u00a0(2nd\u00a0Gen)",
-        "CHIP": "GM206",
-        "Desktop/Mobile/Server": "D",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": "1",
-        "Total # of NVENC": "1",
-        "Max # of concurrent sessions": 2.0,
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": true
-      },
-      "GeForce GTX 965M": {
-        "BOARD": "GeForce GTX 965M",
-        "FAMILY": "Maxwell\u00a0(2nd\u00a0Gen)",
-        "CHIP": "GM206",
-        "Desktop/Mobile/Server": "M",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": "1",
-        "Total # of NVENC": "1",
-        "Max # of concurrent sessions": 2.0,
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": true
-      },
-      "GeForce GTX 910M / 920M / 920A": {
-        "BOARD": "GeForce GTX 910M / 920M / 920A",
-        "FAMILY": "Maxwell\u00a0(2nd\u00a0Gen)",
-        "CHIP": "GM208B",
-        "Desktop/Mobile/Server": "M",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": "1",
-        "Total # of NVENC": "1",
-        "Max # of concurrent sessions": 2.0,
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": false,
-        "H.264 (AVCHD) Lossless": false,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": false
-      },
-      "GeForce GTX 965M > 980M / 980MX": {
-        "BOARD": "GeForce GTX 965M > 980M / 980MX",
-        "FAMILY": "Maxwell\u00a0(2nd\u00a0Gen)",
-        "CHIP": "GM204",
-        "Desktop/Mobile/Server": "M",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": "2",
-        "Total # of NVENC": "2",
-        "Max # of concurrent sessions": 2.0,
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": true
-      },
-      "GeForce GTX 960 Ti - 980": {
-        "BOARD": "GeForce GTX 960 Ti - 980",
-        "FAMILY": "Maxwell\u00a0(2nd\u00a0Gen)",
-        "CHIP": "GM204",
-        "Desktop/Mobile/Server": "D",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": "2",
-        "Total # of NVENC": "2",
-        "Max # of concurrent sessions": 2.0,
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": true
-      },
-      "GeForce GTX 980 Ti": {
-        "BOARD": "GeForce GTX 980 Ti",
-        "FAMILY": "Maxwell\u00a0(2nd\u00a0Gen)",
-        "CHIP": "GM200",
-        "Desktop/Mobile/Server": "D",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": "2",
-        "Total # of NVENC": "2",
-        "Max # of concurrent sessions": 2.0,
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": true
-      },
-      "GeForce GTX Titan X": {
-        "BOARD": "GeForce GTX Titan X",
-        "FAMILY": "Maxwell\u00a0(2nd\u00a0Gen)",
-        "CHIP": "GM200",
-        "Desktop/Mobile/Server": "D",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": "2",
-        "Total # of NVENC": "2",
-        "Max # of concurrent sessions": 2.0,
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": true
-      },
-      "GeForce MX150 > MX250": {
-        "BOARD": "GeForce MX150 > MX250",
-        "FAMILY": "Pascal",
-        "CHIP": "GP108",
-        "Desktop/Mobile/Server": "M",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": "0",
-        "Total # of NVENC": "0",
-        "Max # of concurrent sessions": 0.0,
-        "H.264 (AVCHD) YUV 4:2:0": false,
-        "H.264 (AVCHD) YUV 4:4:4": false,
-        "H.264 (AVCHD) Lossless": false,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": false,
-        "hevc": false
-      },
-      "Quadro K420 / K600": {
-        "BOARD": "Quadro K420 / K600",
-        "FAMILY": "Kepler",
-        "CHIP": "GK107",
-        "Desktop/Mobile/Server": "D",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": 1,
-        "Total # of NVENC": 1,
-        "Max # of concurrent sessions": "2",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": false,
-        "H.264 (AVCHD) Lossless": false,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": false
-      },
-      "Quadro K2000 / K2000D": {
-        "BOARD": "Quadro K2000 / K2000D",
-        "FAMILY": "Kepler",
-        "CHIP": "GK107",
-        "Desktop/Mobile/Server": "D",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": 1,
-        "Total # of NVENC": 1,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": false,
-        "H.264 (AVCHD) Lossless": false,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": false
-      },
-      "Quadro K2100 > K5000": {
-        "BOARD": "Quadro K2100 > K5000",
-        "FAMILY": "Kepler",
-        "CHIP": "GK106",
-        "Desktop/Mobile/Server": "M",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": 1,
-        "Total # of NVENC": 1,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": false,
-        "H.264 (AVCHD) Lossless": false,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": false
-      },
-      "Quadro K4000": {
-        "BOARD": "Quadro K4000",
-        "FAMILY": "Kepler",
-        "CHIP": "GK106",
-        "Desktop/Mobile/Server": "D",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": 1,
-        "Total # of NVENC": 1,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": false,
-        "H.264 (AVCHD) Lossless": false,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": false
-      },
-      "Quadro K100 > K2000 + K5100": {
-        "BOARD": "Quadro K100 > K2000 + K5100",
-        "FAMILY": "Kepler",
-        "CHIP": "GK104",
-        "Desktop/Mobile/Server": "M",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": 1,
-        "Total # of NVENC": 1,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": false,
-        "H.264 (AVCHD) Lossless": false,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": false
-      },
-      "Quadro K4200 / K5000": {
-        "BOARD": "Quadro K4200 / K5000",
-        "FAMILY": "Kepler",
-        "CHIP": "GK104",
-        "Desktop/Mobile/Server": "D",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": 1,
-        "Total # of NVENC": 1,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": false,
-        "H.264 (AVCHD) Lossless": false,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": false
-      },
-      "Quadro K5200 / K6000": {
-        "BOARD": "Quadro K5200 / K6000",
-        "FAMILY": "Kepler (2nd Gen)",
-        "CHIP": "GK110B",
-        "Desktop/Mobile/Server": "D",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": 1,
-        "Total # of NVENC": 1,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": false,
-        "H.264 (AVCHD) Lossless": false,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": false
-      },
-      "Quadro K620 / K1200": {
-        "BOARD": "Quadro K620 / K1200",
-        "FAMILY": "Maxwell (1st Gen)",
-        "CHIP": "GM107",
-        "Desktop/Mobile/Server": "D",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": 1,
-        "Total # of NVENC": 1,
-        "Max # of concurrent sessions": "2",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": false
-      },
-      "Quadro K2200": {
-        "BOARD": "Quadro K2200",
-        "FAMILY": "Maxwell (1st Gen)",
-        "CHIP": "GM107",
-        "Desktop/Mobile/Server": "D",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": 1,
-        "Total # of NVENC": 1,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": false
-      },
-      "Quadro M500 / M520": {
-        "BOARD": "Quadro M500 / M520",
-        "FAMILY": "Maxwell (1st Gen)",
-        "CHIP": "GM108",
-        "Desktop/Mobile/Server": "M",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": 0,
-        "Total # of NVENC": 0,
-        "Max # of concurrent sessions": NaN,
-        "H.264 (AVCHD) YUV 4:2:0": false,
-        "H.264 (AVCHD) YUV 4:4:4": false,
-        "H.264 (AVCHD) Lossless": false,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": false,
-        "hevc": false
-      },
-      "Quadro M600 / M620": {
-        "BOARD": "Quadro M600 / M620",
-        "FAMILY": "Maxwell (1st Gen)",
-        "CHIP": "GM107",
-        "Desktop/Mobile/Server": "M",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": 1,
-        "Total # of NVENC": 1,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": false
-      },
-      "Quadro M1000 / M1200 / M2000": {
-        "BOARD": "Quadro M1000 / M1200 / M2000",
-        "FAMILY": "Maxwell (1st Gen)",
-        "CHIP": "GM107",
-        "Desktop/Mobile/Server": "M",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": 1,
-        "Total # of NVENC": 1,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": false
-      },
-      "Quadro M2000": {
-        "BOARD": "Quadro M2000",
-        "FAMILY": "Maxwell (GM206)",
-        "CHIP": "GM206",
-        "Desktop/Mobile/Server": "D",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": 1,
-        "Total # of NVENC": 1,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": true
-      },
-      "Quadro M2200": {
-        "BOARD": "Quadro M2200",
-        "FAMILY": "Maxwell (GM206)",
-        "CHIP": "GM206",
-        "Desktop/Mobile/Server": "M",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": 1,
-        "Total # of NVENC": 1,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": true
-      },
-      "Quadro M3000 / M4000 / M5500": {
-        "BOARD": "Quadro M3000 / M4000 / M5500",
-        "FAMILY": "Maxwell (2nd Gen)",
-        "CHIP": "GM204",
-        "Desktop/Mobile/Server": "M",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": 2,
-        "Total # of NVENC": 2,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": true
-      },
-      "Quadro M4000 / M5000": {
-        "BOARD": "Quadro M4000 / M5000",
-        "FAMILY": "Maxwell (2nd Gen)",
-        "CHIP": "GM204",
-        "Desktop/Mobile/Server": "D",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": 2,
-        "Total # of NVENC": 2,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": true
-      },
-      "Quadro M6000": {
-        "BOARD": "Quadro M6000",
-        "FAMILY": "Maxwell\u00a0(2nd\u00a0Gen)",
-        "CHIP": "GM200",
-        "Desktop/Mobile/Server": "D",
-        "# OF CHIPS": 1,
-        "# OF NVENC/CHIP": 2,
-        "Total # of NVENC": 2,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": true
-      },
-      "GRID K1": {
-        "BOARD": "GRID K1",
-        "FAMILY": "Kepler",
-        "CHIP": "GK107",
-        "# OF CHIPS": 4.0,
-        "# OF NVENC/CHIP": 1.0,
-        "Total # of NVENC": 4.0,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": false,
-        "H.264 (AVCHD) Lossless": false,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": false
-      },
-      "GRID K2": {
-        "BOARD": "GRID K2",
-        "FAMILY": "Kepler",
-        "CHIP": "GK104",
-        "# OF CHIPS": 2.0,
-        "# OF NVENC/CHIP": 1.0,
-        "Total # of NVENC": 2.0,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": false,
-        "H.264 (AVCHD) Lossless": false,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": false
-      },
-      "GRID K340": {
-        "BOARD": "GRID K340",
-        "FAMILY": "Kepler",
-        "CHIP": "GK107",
-        "# OF CHIPS": 4.0,
-        "# OF NVENC/CHIP": 1.0,
-        "Total # of NVENC": 4.0,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": false,
-        "H.264 (AVCHD) Lossless": false,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": false
-      },
-      "GRID K520": {
-        "BOARD": "GRID K520",
-        "FAMILY": "Kepler",
-        "CHIP": "GK104",
-        "# OF CHIPS": 2.0,
-        "# OF NVENC/CHIP": 1.0,
-        "Total # of NVENC": 2.0,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": false,
-        "H.264 (AVCHD) Lossless": false,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": false
-      },
-      "Tesla K10": {
-        "BOARD": "Tesla K10",
-        "FAMILY": "Kepler",
-        "CHIP": "GK104",
-        "# OF CHIPS": 2.0,
-        "# OF NVENC/CHIP": 1.0,
-        "Total # of NVENC": 2.0,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": false,
-        "H.264 (AVCHD) Lossless": false,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": false
-      },
-      "Tesla K20X": {
-        "BOARD": "Tesla K20X",
-        "FAMILY": "Kepler",
-        "CHIP": "GK110",
-        "# OF CHIPS": 1.0,
-        "# OF NVENC/CHIP": 1.0,
-        "Total # of NVENC": 1.0,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": false,
-        "H.264 (AVCHD) Lossless": false,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": false
-      },
-      "Tesla K40": {
-        "BOARD": "Tesla K40",
-        "FAMILY": "Kepler",
-        "CHIP": "GK110B",
-        "# OF CHIPS": 1.0,
-        "# OF NVENC/CHIP": 1.0,
-        "Total # of NVENC": 1.0,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": false,
-        "H.264 (AVCHD) Lossless": false,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": false
-      },
-      "Tesla K80": {
-        "BOARD": "Tesla K80",
-        "FAMILY": "Kepler (2nd Gen)",
-        "CHIP": "GK210",
-        "# OF CHIPS": 2.0,
-        "# OF NVENC/CHIP": 1.0,
-        "Total # of NVENC": 2.0,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": false,
-        "H.264 (AVCHD) Lossless": false,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": false
-      },
-      "Tesla M10": {
-        "BOARD": "Tesla M10",
-        "FAMILY": "Maxwell (1st Gen)",
-        "CHIP": "GM107",
-        "# OF CHIPS": 4.0,
-        "# OF NVENC/CHIP": 1.0,
-        "Total # of NVENC": 4.0,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": false,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": false
-      },
-      "Tesla M4": {
-        "BOARD": "Tesla M4",
-        "FAMILY": "Maxwell (GM206)",
-        "CHIP": "GM206",
-        "# OF CHIPS": 1.0,
-        "# OF NVENC/CHIP": 1.0,
-        "Total # of NVENC": 1.0,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": true
-      },
-      "Tesla M40": {
-        "BOARD": "Tesla M40",
-        "FAMILY": "Maxwell\u00a0(2nd\u00a0Gen)",
-        "CHIP": "GM200",
-        "# OF CHIPS": 1.0,
-        "# OF NVENC/CHIP": 2.0,
-        "Total # of NVENC": 2.0,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": true
-      },
-      "Tesla M6": {
-        "BOARD": "Tesla M6",
-        "FAMILY": "Maxwell\u00a0(2nd\u00a0Gen)",
-        "CHIP": "GM204",
-        "# OF CHIPS": 1.0,
-        "# OF NVENC/CHIP": 2.0,
-        "Total # of NVENC": 2.0,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": true
-      },
-      "Tesla M60": {
-        "BOARD": "Tesla M60",
-        "FAMILY": "Maxwell\u00a0(2nd\u00a0Gen)",
-        "CHIP": "GM204",
-        "# OF CHIPS": 2.0,
-        "# OF NVENC/CHIP": 2.0,
-        "Total # of NVENC": 4.0,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": false,
-        "H.265 (HEVC) 4K Lossless": false,
-        "H.265 (HEVC) 8k": false,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": true
-      },
-      "Tesla P4": {
-        "BOARD": "Tesla P4",
-        "FAMILY": "Pascal",
-        "CHIP": "GP104",
-        "# OF CHIPS": 1.0,
-        "# OF NVENC/CHIP": 2.0,
-        "Total # of NVENC": 2.0,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": true,
-        "H.265 (HEVC) 4K Lossless": true,
-        "H.265 (HEVC) 8k": true,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": true
+    "decoders": {
+      "model_lines": {
+        "geforce gt": {
+          "models": {
+            "1030": "GeForce GT 1030",
+            "723a": "GeForce GT 723A / 740A",
+            "740a": "GeForce GT 723A / 740A",
+            "630": "GeForce GT 630 / 635/ 640 / 710 / 730",
+            "635": "GeForce GT 630 / 635/ 640 / 710 / 730",
+            "640": "GeForce GT 630 / 635/ 640 / 710 / 730",
+            "710": "GeForce GT 630 / 635/ 640 / 710 / 730",
+            "730": "GeForce GT 630 / 635/ 640 / 710 / 730",
+            "740": "GeForce GTX 645 -660 Ti Boost GeForce GT 740"
+          },
+          "model_ranges": [
+            [
+              "720m > 740m",
+              "GeForce GT 720M > 740M"
+            ],
+            [
+              "640m > 755m",
+              "GeForce GT 640M > 755M / GTX 660M"
+            ],
+            [
+              "630 - 640",
+              "GeForce GT 630 - 640 GeForce GTX 650 GeForce GT 740"
+            ],
+            [
+              "780 - 780 ti",
+              "GeForce GT 780 - 780 Ti"
+            ]
+          ]
+        },
+        "geforce gtx": {
+          "models": {
+            "1050": "GeForce GTX 1050 / 1050 Ti",
+            "1050 ti": "GeForce GTX 1050 / 1050 Ti",
+            "1060": "GeForce GTX 1060",
+            "1070m": "GeForce GTX 1070M / 1080M",
+            "1080m": "GeForce GTX 1070M / 1080M",
+            "1070": "GeForce GTX 1070 / 1070 Ti / 1080",
+            "1070 ti": "GeForce GTX 1070 / 1070 Ti / 1080",
+            "1080": "GeForce GTX 1070 / 1070 Ti / 1080",
+            "1080 ti": "GeForce GTX 1080 Ti",
+            "1650": "GeForce GTX 1650",
+            "1660 ti": "GeForce GTX 1660 Ti / 1660",
+            "1660": "GeForce GTX 1660 Ti / 1660",
+            "650": "GeForce GT 630 - 640 GeForce GTX 650 GeForce GT 740",
+            "760a": "GeForce GTX 760A/M > 880M",
+            "680m": "GeForce GTX 680M/MX > 880M",
+            "750": "GeForce GTX 750 GeForce GTX 950 - 960",
+            "965m": "GeForce GTX 965M",
+            "910m": "GeForce GTX 910M / 920M / 920A",
+            "920m": "GeForce GTX 910M / 920M / 920A",
+            "920a": "GeForce GTX 910M / 920M / 920A",
+            "980mx": "GeForce GTX 965M > 980M / 980MX",
+            "960 ti": "GeForce GTX 960 Ti / 970 / 980",
+            "970": "GeForce GTX 960 Ti / 970 / 980",
+            "980": "GeForce GTX 960 Ti / 970 / 980",
+            "980 ti": "GeForce GTX 980 Ti",
+            "660m": "GeForce GT 640M > 755M / GTX 660M",
+            "titan": "GeForce GTX Titan / Titan Black"
+          },
+          "model_ranges": [
+            [
+              "645 -660 ti boost",
+              "GeForce GTX 645 -660 Ti Boost GeForce GT 740"
+            ],
+            [
+              "660 - 690",
+              "GeForce GTX 660 - 690 GeForce GTX 760 - 770"
+            ],
+            [
+              "760 - 770",
+              "GeForce GTX 660 - 690 GeForce GTX 760 - 770"
+            ],
+            [
+              "m > 880m",
+              "GeForce GTX 760A/M > 880M"
+            ],
+            [
+              "mx > 880m",
+              "GeForce GTX 680M/MX > 880M"
+            ],
+            [
+              "745 - 750 ti",
+              "GeForce GTX 745 - 750 Ti"
+            ],
+            [
+              "850a > 960a",
+              "GeForce GTX 850A > 960A"
+            ],
+            [
+              "850m > 960m",
+              "GeForce GTX 850M > 960M"
+            ],
+            [
+              "920mx - 940mx",
+              "GeForce GTX 920MX - 940MX"
+            ],
+            [
+              "950 - 960",
+              "GeForce GTX 750 GeForce GTX 950 - 960"
+            ],
+            [
+              "965m > 980m",
+              "GeForce GTX 965M > 980M / 980MX"
+            ]
+          ]
+        },
+        "geforce gtx titan": {
+          "models": {
+            "x": "GeForce GTX Titan X / Titan Xp",
+            "z": "GeForce GTX Titan Z",
+            "xp": "GeForce GTX Titan X / Titan Xp",
+            "black": "GeForce GTX Titan / Titan Black"
+          },
+          "model_ranges": []
+        },
+        "titan": {
+          "models": {
+            "v": "Titan V",
+            "rtx": "Titan RTX"
+          },
+          "model_ranges": []
+        },
+        "geforce rtx": {
+          "models": {
+            "2060": "GeForce RTX 2060 / 2070",
+            "2070": "GeForce RTX 2060 / 2070",
+            "2080": "GeForce RTX 2080",
+            "2080 ti": "GeForce RTX 2080 Ti"
+          },
+          "model_ranges": []
+        },
+        "quadro": {
+          "models": {
+            "p500": "Quadro P500 / P520",
+            "p520": "Quadro P500 / P520",
+            "p400": "Quadro P400",
+            "p600": "Quadro P600 / P1000",
+            "p1000": "Quadro P600 / P1000",
+            "p2000": "Quadro P2000 / P2200",
+            "p2200": "Quadro P2000 / P2200",
+            "p3200": "Quadro P3200 / P4200 / P5200",
+            "p4200": "Quadro P3200 / P4200 / P5200",
+            "p5200": "Quadro P3200 / P4200 / P5200",
+            "p4000": "Quadro P4000 / P5000",
+            "p5000": "Quadro P4000 / P5000",
+            "p6000": "Quadro P6000",
+            "gp100": "Quadro GP100",
+            "gv100": "Quadro GV100",
+            "t1000": "Quadro T1000 / T2000",
+            "t2000": "Quadro T1000 / T2000",
+            "rtx 3000": "Quadro RTX 3000",
+            "rtx 4000": "Quadro RTX 4000/RTX 5000",
+            "rtx 5000": "Quadro RTX 4000/RTX 5000",
+            "rtx 6000": "Quadro RTX 6000/RTX 8000",
+            "rtx 8000": "Quadro RTX 6000/RTX 8000",
+            "k420": "Quadro K420 / K600",
+            "k600": "Quadro K420 / K600",
+            "k2000": "Quadro K2000 / K2000D",
+            "k2000d": "Quadro K2000 / K2000D",
+            "k4000": "Quadro K4000",
+            "k5100": "Quadro K100 > K2000 + K5100",
+            "k4200": "Quadro K4200 / K5000",
+            "k5000": "Quadro K4200 / K5000",
+            "k5200": "Quadro K5200 / K6000",
+            "k6000": "Quadro K5200 / K6000",
+            "k620": "Quadro K620 / K1200",
+            "k1200": "Quadro K620 / K1200",
+            "k2200": "Quadro K2200",
+            "m500": "Quadro M500 / M520",
+            "m520": "Quadro M500 / M520",
+            "m600": "Quadro M600 / M620",
+            "m620": "Quadro M600 / M620",
+            "m1000": "Quadro M1000 / M1200 / M2000",
+            "m1200": "Quadro M1000 / M1200 / M2000",
+            "m2000": "Quadro M2000",
+            "m2200": "Quadro M2200",
+            "m3000": "Quadro M3000 / M4000 / M5500",
+            "m4000": "Quadro M4000 / M5000",
+            "m5500": "Quadro M3000 / M4000 / M5500",
+            "m5000": "Quadro M4000 / M5000",
+            "m6000": "Quadro M6000"
+          },
+          "model_ranges": [
+            [
+              "k2100 > k5100",
+              "Quadro K2100 > K5100"
+            ],
+            [
+              "k100 > k2000",
+              "Quadro K100 > K2000 + K5100"
+            ]
+          ]
+        },
+        "tesla": {
+          "models": {
+            "p4": "Tesla P4 / P6",
+            "p6": "Tesla P4 / P6",
+            "p40": "Tesla P40",
+            "p100": "Tesla P100",
+            "v100": "Tesla V100",
+            "t4": "Tesla T4",
+            "k10": "Tesla K10",
+            "k20x": "Tesla K20X",
+            "k40": "Tesla K40",
+            "k80": "Tesla K80",
+            "m10": "Tesla M10",
+            "m4": "Tesla M4",
+            "m6": "Tesla M6",
+            "m60": "Tesla M60",
+            "m40": "Tesla M40"
+          },
+          "model_ranges": []
+        },
+        "geforce": {
+          "models": {
+            "710a": "GeForce 710A / 810M / 820M",
+            "810m": "GeForce 710A / 810M / 820M",
+            "820m": "GeForce 710A / 810M / 820M",
+            "845m": "GeForce 845M / 940M / 940MX / 945M",
+            "940m": "GeForce 845M / 940M / 940MX / 945M",
+            "940mx": "GeForce 845M / 940M / 940MX / 945M",
+            "945m": "GeForce 845M / 940M / 940MX / 945M",
+            "mx110": "GeForce MX110 / MX130",
+            "mx130": "GeForce MX110 / MX130",
+            "mx150": "GeForce MX150",
+            "mx230": "GeForce MX230 / MX250",
+            "mx250": "GeForce MX230 / MX250"
+          },
+          "model_ranges": [
+            [
+              "710a > 810a",
+              "GeForce 710A > 810A"
+            ],
+            [
+              "830a > 945a",
+              "GeForce 830A > 945A"
+            ],
+            [
+              "830m > 945m",
+              "GeForce 830M > 945M"
+            ]
+          ]
+        },
+        "grid": {
+          "models": {
+            "k1": "GRID K1",
+            "k2": "GRID K2",
+            "k340": "GRID K340",
+            "k520": "GRID K520"
+          },
+          "model_ranges": []
+        }
       },
-      "Tesla P6": {
-        "BOARD": "Tesla P6",
-        "FAMILY": "Pascal",
-        "CHIP": "GP104",
-        "# OF CHIPS": 1.0,
-        "# OF NVENC/CHIP": 2.0,
-        "Total # of NVENC": 2.0,
-        "Max # of concurrent sessions": "Unrestricted",
-        "H.264 (AVCHD) YUV 4:2:0": true,
-        "H.264 (AVCHD) YUV 4:4:4": true,
-        "H.264 (AVCHD) Lossless": true,
-        "H.265 (HEVC) 4K YUV 4:2:0": true,
-        "H.265 (HEVC) 4K YUV 4:4:4": true,
-        "H.265 (HEVC) 4K Lossless": true,
-        "H.265 (HEVC) 8k": true,
-        "HEVC B Frame support": false,
-        "h264": true,
-        "hevc": true
+      "boards": {
+        "GeForce GT 1030": {
+          "BOARD": "GeForce GT 1030",
+          "FAMILY": "Pascal",
+          "CHIP": "GP108",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": true,
+          "VP9 10\u00a0bit": true,
+          "VP9 12\u00a0bit": true,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": true,
+          "h264": true,
+          "hevc": true
+        },
+        "GeForce GTX 1050 / 1050 Ti": {
+          "BOARD": "GeForce GTX 1050 / 1050 Ti",
+          "FAMILY": "Pascal",
+          "CHIP": "GP106",
+          "Desktop/Mobile/Server": "D/M",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": true,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": true,
+          "h264": true,
+          "hevc": true
+        },
+        "GeForce GTX 1060": {
+          "BOARD": "GeForce GTX 1060",
+          "FAMILY": "Pascal",
+          "CHIP": "GP104",
+          "Desktop/Mobile/Server": "D/M",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": true,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": true,
+          "h264": true,
+          "hevc": true
+        },
+        "GeForce GTX 1070M / 1080M": {
+          "BOARD": "GeForce GTX 1070M / 1080M",
+          "FAMILY": "Pascal",
+          "CHIP": "GP104B",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": true,
+          "VP9 8\u00a0bit": true,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": true,
+          "vp9": true,
+          "h264": true,
+          "hevc": true
+        },
+        "GeForce GTX 1070 / 1070 Ti / 1080": {
+          "BOARD": "GeForce GTX 1070 / 1070 Ti / 1080",
+          "FAMILY": "Pascal",
+          "CHIP": "GP104",
+          "Desktop/Mobile/Server": "D/M",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": true,
+          "VP9 8\u00a0bit": true,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": true,
+          "vp9": true,
+          "h264": true,
+          "hevc": true
+        },
+        "GeForce GTX 1080 Ti": {
+          "BOARD": "GeForce GTX 1080 Ti",
+          "FAMILY": "Pascal",
+          "CHIP": "GP102",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": true,
+          "VP9 10\u00a0bit": true,
+          "VP9 12\u00a0bit": true,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": true,
+          "h264": true,
+          "hevc": true
+        },
+        "GeForce GTX Titan X / Titan Xp": {
+          "BOARD": "GeForce GTX Titan X / Titan Xp",
+          "FAMILY": "Pascal",
+          "CHIP": "GP102",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": true,
+          "VP9 10\u00a0bit": true,
+          "VP9 12\u00a0bit": true,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": true,
+          "h264": true,
+          "hevc": true
+        },
+        "Titan V": {
+          "BOARD": "Titan V",
+          "FAMILY": "Volta",
+          "CHIP": "GV100",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": true,
+          "VP9 8\u00a0bit": true,
+          "VP9 10\u00a0bit": true,
+          "VP9 12\u00a0bit": true,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": true,
+          "vp9": true,
+          "h264": true,
+          "hevc": true
+        },
+        "GeForce GTX 1650": {
+          "BOARD": "GeForce GTX 1650",
+          "FAMILY": "Turing",
+          "CHIP": "TU117",
+          "Desktop/Mobile/Server": "D/M",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": true,
+          "VP9 8\u00a0bit": true,
+          "VP9 10\u00a0bit": true,
+          "VP9 12\u00a0bit": true,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": true,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": true,
+          "vp9": true,
+          "h264": true,
+          "hevc": true
+        },
+        "GeForce GTX 1660 Ti / 1660": {
+          "BOARD": "GeForce GTX 1660 Ti / 1660",
+          "FAMILY": "Turing",
+          "CHIP": "TU116",
+          "Desktop/Mobile/Server": "D/M",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": true,
+          "VP9 8\u00a0bit": true,
+          "VP9 10\u00a0bit": true,
+          "VP9 12\u00a0bit": true,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": true,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": true,
+          "vp9": true,
+          "h264": true,
+          "hevc": true
+        },
+        "GeForce RTX 2060 / 2070": {
+          "BOARD": "GeForce RTX 2060 / 2070",
+          "FAMILY": "Turing",
+          "CHIP": "TU106",
+          "Desktop/Mobile/Server": "D/M",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": true,
+          "VP9 8\u00a0bit": true,
+          "VP9 10\u00a0bit": true,
+          "VP9 12\u00a0bit": true,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": true,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": true,
+          "vp9": true,
+          "h264": true,
+          "hevc": true
+        },
+        "GeForce RTX 2080": {
+          "BOARD": "GeForce RTX 2080",
+          "FAMILY": "Turing",
+          "CHIP": "TU104",
+          "Desktop/Mobile/Server": "D/M",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": true,
+          "VP9 8\u00a0bit": true,
+          "VP9 10\u00a0bit": true,
+          "VP9 12\u00a0bit": true,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": true,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": true,
+          "vp9": true,
+          "h264": true,
+          "hevc": true
+        },
+        "GeForce RTX 2080 Ti": {
+          "BOARD": "GeForce RTX 2080 Ti",
+          "FAMILY": "Turing",
+          "CHIP": "TU102",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": true,
+          "VP9 8\u00a0bit": true,
+          "VP9 10\u00a0bit": true,
+          "VP9 12\u00a0bit": true,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": true,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": true,
+          "vp9": true,
+          "h264": true,
+          "hevc": true
+        },
+        "Titan RTX": {
+          "BOARD": "Titan RTX",
+          "FAMILY": "Turing",
+          "CHIP": "TU102",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": true,
+          "VP9 8\u00a0bit": true,
+          "VP9 10\u00a0bit": true,
+          "VP9 12\u00a0bit": true,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": true,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": true,
+          "vp9": true,
+          "h264": true,
+          "hevc": true
+        },
+        "Quadro P500 / P520": {
+          "BOARD": "Quadro P500 / P520",
+          "FAMILY": "Pascal",
+          "CHIP": "GP108",
+          "# OF CHIPS": "M",
+          "Desktop/Mobile/Server": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": true,
+          "VP9 10\u00a0bit": true,
+          "VP9 12\u00a0bit": true,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": true,
+          "h264": true,
+          "hevc": true
+        },
+        "Quadro P400": {
+          "BOARD": "Quadro P400",
+          "FAMILY": "Pascal",
+          "CHIP": "GP107",
+          "# OF CHIPS": "D",
+          "Desktop/Mobile/Server": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": true,
+          "VP9 10\u00a0bit": true,
+          "VP9 12\u00a0bit": true,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": true,
+          "h264": true,
+          "hevc": true
+        },
+        "Quadro P600 / P1000": {
+          "BOARD": "Quadro P600 / P1000",
+          "FAMILY": "Pascal",
+          "CHIP": "GP107",
+          "# OF CHIPS": "D/M",
+          "Desktop/Mobile/Server": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": true,
+          "VP9 10\u00a0bit": true,
+          "VP9 12\u00a0bit": true,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": true,
+          "h264": true,
+          "hevc": true
+        },
+        "Quadro P2000": {
+          "BOARD": "Quadro P2000",
+          "FAMILY": "Pascal",
+          "CHIP": "GP107",
+          "# OF CHIPS": "M",
+          "Desktop/Mobile/Server": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": true,
+          "VP9 10\u00a0bit": true,
+          "VP9 12\u00a0bit": true,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": true,
+          "h264": true,
+          "hevc": true
+        },
+        "Quadro P2000 / P2200": {
+          "BOARD": "Quadro P2000 / P2200",
+          "FAMILY": "Pascal",
+          "CHIP": "GP106",
+          "# OF CHIPS": "D",
+          "Desktop/Mobile/Server": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": true,
+          "VP9 10\u00a0bit": true,
+          "VP9 12\u00a0bit": true,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": true,
+          "h264": true,
+          "hevc": true
+        },
+        "Quadro P3200 / P4200 / P5200": {
+          "BOARD": "Quadro P3200 / P4200 / P5200",
+          "FAMILY": "Pascal",
+          "CHIP": "GP104",
+          "# OF CHIPS": "M",
+          "Desktop/Mobile/Server": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": true,
+          "VP9 8\u00a0bit": true,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": true,
+          "vp9": true,
+          "h264": true,
+          "hevc": true
+        },
+        "Quadro P4000 / P5000": {
+          "BOARD": "Quadro P4000 / P5000",
+          "FAMILY": "Pascal",
+          "CHIP": "GP104",
+          "# OF CHIPS": "D",
+          "Desktop/Mobile/Server": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": true,
+          "VP9 8\u00a0bit": true,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": true,
+          "vp9": true,
+          "h264": true,
+          "hevc": true
+        },
+        "Quadro P6000": {
+          "BOARD": "Quadro P6000",
+          "FAMILY": "Pascal",
+          "CHIP": "GP102",
+          "# OF CHIPS": "D",
+          "Desktop/Mobile/Server": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": true,
+          "VP9 10\u00a0bit": true,
+          "VP9 12\u00a0bit": true,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": true,
+          "h264": true,
+          "hevc": true
+        },
+        "Quadro GP100": {
+          "BOARD": "Quadro GP100",
+          "FAMILY": "Pascal",
+          "CHIP": "GP100",
+          "# OF CHIPS": "D",
+          "Desktop/Mobile/Server": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": true,
+          "VP9 8\u00a0bit": true,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": true,
+          "vp9": true,
+          "h264": true,
+          "hevc": true
+        },
+        "Quadro GV100": {
+          "BOARD": "Quadro GV100",
+          "FAMILY": "Volta",
+          "CHIP": "GV100",
+          "# OF CHIPS": "D",
+          "Desktop/Mobile/Server": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": true,
+          "VP9 8\u00a0bit": true,
+          "VP9 10\u00a0bit": true,
+          "VP9 12\u00a0bit": true,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": true,
+          "vp9": true,
+          "h264": true,
+          "hevc": true
+        },
+        "Quadro T1000 / T2000": {
+          "BOARD": "Quadro T1000 / T2000",
+          "FAMILY": "Turing",
+          "CHIP": "TU117",
+          "# OF CHIPS": "M",
+          "Desktop/Mobile/Server": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": true,
+          "VP9 8\u00a0bit": true,
+          "VP9 10\u00a0bit": true,
+          "VP9 12\u00a0bit": true,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": true,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": true,
+          "vp9": true,
+          "h264": true,
+          "hevc": true
+        },
+        "Quadro RTX 3000": {
+          "BOARD": "Quadro RTX 3000",
+          "FAMILY": "Turing",
+          "CHIP": "TU106",
+          "# OF CHIPS": "M",
+          "Desktop/Mobile/Server": 1,
+          "# OF NVDEC/CHIP": 3,
+          "Total # of NDEC": 3,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": true,
+          "VP9 8\u00a0bit": true,
+          "VP9 10\u00a0bit": true,
+          "VP9 12\u00a0bit": true,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": true,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": true,
+          "vp9": true,
+          "h264": true,
+          "hevc": true
+        },
+        "Quadro RTX 4000/RTX 5000": {
+          "BOARD": "Quadro RTX 4000/RTX 5000",
+          "FAMILY": "Turing",
+          "CHIP": "TU104",
+          "# OF CHIPS": "D/M",
+          "Desktop/Mobile/Server": 1,
+          "# OF NVDEC/CHIP": 2,
+          "Total # of NDEC": 2,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": true,
+          "VP9 8\u00a0bit": true,
+          "VP9 10\u00a0bit": true,
+          "VP9 12\u00a0bit": true,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": true,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": true,
+          "vp9": true,
+          "h264": true,
+          "hevc": true
+        },
+        "Quadro RTX 6000/RTX 8000": {
+          "BOARD": "Quadro RTX 6000/RTX 8000",
+          "FAMILY": "Turing",
+          "CHIP": "TU102",
+          "# OF CHIPS": "D",
+          "Desktop/Mobile/Server": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": true,
+          "VP9 8\u00a0bit": true,
+          "VP9 10\u00a0bit": true,
+          "VP9 12\u00a0bit": true,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": true,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": true,
+          "vp9": true,
+          "h264": true,
+          "hevc": true
+        },
+        "Tesla P4 / P6": {
+          "BOARD": "Tesla P4 / P6",
+          "FAMILY": "Pascal",
+          "CHIP": "GP104",
+          "# OF CHIPS": 1.0,
+          "# OF NVDEC/CHIP": 1.0,
+          "Total # of NDEC": 1.0,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": true,
+          "VP9 8\u00a0bit": true,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": true,
+          "vp9": true,
+          "h264": true,
+          "hevc": true
+        },
+        "Tesla P40": {
+          "BOARD": "Tesla P40",
+          "FAMILY": "Pascal",
+          "CHIP": "GP102",
+          "# OF CHIPS": 1.0,
+          "# OF NVDEC/CHIP": 1.0,
+          "Total # of NDEC": 1.0,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": true,
+          "VP9 10\u00a0bit": true,
+          "VP9 12\u00a0bit": true,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": true,
+          "h264": true,
+          "hevc": true
+        },
+        "Tesla P100": {
+          "BOARD": "Tesla P100",
+          "FAMILY": "Pascal",
+          "CHIP": "GP100",
+          "# OF CHIPS": 1.0,
+          "# OF NVDEC/CHIP": 1.0,
+          "Total # of NDEC": 1.0,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": true,
+          "VP9 8\u00a0bit": true,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": true,
+          "vp9": true,
+          "h264": true,
+          "hevc": true
+        },
+        "Tesla V100": {
+          "BOARD": "Tesla V100",
+          "FAMILY": "Volta",
+          "CHIP": "GV100",
+          "# OF CHIPS": 1.0,
+          "# OF NVDEC/CHIP": 1.0,
+          "Total # of NDEC": 1.0,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": true,
+          "VP9 8\u00a0bit": true,
+          "VP9 10\u00a0bit": true,
+          "VP9 12\u00a0bit": true,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": true,
+          "vp9": true,
+          "h264": true,
+          "hevc": true
+        },
+        "Tesla T4": {
+          "BOARD": "Tesla T4",
+          "FAMILY": "Turing",
+          "CHIP": "TU104",
+          "# OF CHIPS": 1.0,
+          "# OF NVDEC/CHIP": 2.0,
+          "Total # of NDEC": 2.0,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": true,
+          "VP9 8\u00a0bit": true,
+          "VP9 10\u00a0bit": true,
+          "VP9 12\u00a0bit": true,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": true,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": true,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": true,
+          "vp9": true,
+          "h264": true,
+          "hevc": true
+        },
+        "GeForce 710A > 810A": {
+          "BOARD": "GeForce 710A > 810A",
+          "FAMILY": "Kepler",
+          "CHIP": "GK208",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GeForce GT 723A / 740A": {
+          "BOARD": "GeForce GT 723A / 740A",
+          "FAMILY": "Kepler",
+          "CHIP": "GK208",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GeForce GT 720M > 740M": {
+          "BOARD": "GeForce GT 720M > 740M",
+          "FAMILY": "Kepler",
+          "CHIP": "GK208",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GeForce GT 630 / 635/ 640 / 710 / 730": {
+          "BOARD": "GeForce GT 630 / 635/ 640 / 710 / 730",
+          "FAMILY": "Kepler",
+          "CHIP": "GK208",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GeForce 710A / 810M / 820M": {
+          "BOARD": "GeForce 710A / 810M / 820M",
+          "FAMILY": "Kepler",
+          "CHIP": "GK107",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GeForce GT 640M > 755M / GTX 660M": {
+          "BOARD": "GeForce GT 640M > 755M / GTX 660M",
+          "FAMILY": "Kepler",
+          "CHIP": "GK107",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GeForce GT 630 - 640 GeForce GTX 650 GeForce GT 740": {
+          "BOARD": "GeForce GT 630 - 640 GeForce GTX 650 GeForce GT 740",
+          "FAMILY": "Kepler",
+          "CHIP": "GK107",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GeForce GTX 645 -660 Ti Boost GeForce GT 740": {
+          "BOARD": "GeForce GTX 645 -660 Ti Boost GeForce GT 740",
+          "FAMILY": "Kepler",
+          "CHIP": "GK106",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GeForce GTX 660 - 690 GeForce GTX 760 - 770": {
+          "BOARD": "GeForce GTX 660 - 690 GeForce GTX 760 - 770",
+          "FAMILY": "Kepler",
+          "CHIP": "GK104",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GeForce GTX 760A/M > 880M": {
+          "BOARD": "GeForce GTX 760A/M > 880M",
+          "FAMILY": "Kepler",
+          "CHIP": "GK104",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GeForce GTX 680M/MX > 880M": {
+          "BOARD": "GeForce GTX 680M/MX > 880M",
+          "FAMILY": "Kepler",
+          "CHIP": "GK104",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GeForce GT 780 - 780 Ti": {
+          "BOARD": "GeForce GT 780 - 780 Ti",
+          "FAMILY": "Kepler\u00a0(2nd\u00a0Gen)",
+          "CHIP": "GK110",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GeForce GTX Titan / Titan Black": {
+          "BOARD": "GeForce GTX Titan / Titan Black",
+          "FAMILY": "Kepler\u00a0(2nd\u00a0Gen)",
+          "CHIP": "GK110",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GeForce GTX Titan Z": {
+          "BOARD": "GeForce GTX Titan Z",
+          "FAMILY": "Kepler\u00a0(2nd\u00a0Gen)",
+          "CHIP": "GK110",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 2,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 2,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GeForce GTX 745 - 750 Ti": {
+          "BOARD": "GeForce GTX 745 - 750 Ti",
+          "FAMILY": "Maxwell\u00a0(1st\u00a0Gen)",
+          "CHIP": "GM107",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GeForce 845M / 940M / 940MX / 945M": {
+          "BOARD": "GeForce 845M / 940M / 940MX / 945M",
+          "FAMILY": "Maxwell\u00a0(1st\u00a0Gen)",
+          "CHIP": "GM107",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GeForce GTX 850A > 960A": {
+          "BOARD": "GeForce GTX 850A > 960A",
+          "FAMILY": "Maxwell\u00a0(1st\u00a0Gen)",
+          "CHIP": "GM107",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GeForce GTX 850M > 960M": {
+          "BOARD": "GeForce GTX 850M > 960M",
+          "FAMILY": "Maxwell\u00a0(1st\u00a0Gen)",
+          "CHIP": "GM107",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GeForce 830A > 945A": {
+          "BOARD": "GeForce 830A > 945A",
+          "FAMILY": "Maxwell\u00a0(1st\u00a0Gen)",
+          "CHIP": "GM108",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 0,
+          "Total # of NDEC": 0,
+          "MPEG-1": false,
+          "MPEG-2": false,
+          "VC-1": false,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
+          "h264": false,
+          "hevc": false
+        },
+        "GeForce 830M > 945M": {
+          "BOARD": "GeForce 830M > 945M",
+          "FAMILY": "Maxwell\u00a0(1st\u00a0Gen)",
+          "CHIP": "GM108",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 0,
+          "Total # of NDEC": 0,
+          "MPEG-1": false,
+          "MPEG-2": false,
+          "VC-1": false,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
+          "h264": false,
+          "hevc": false
+        },
+        "GeForce GTX 920MX - 940MX": {
+          "BOARD": "GeForce GTX 920MX - 940MX",
+          "FAMILY": "Maxwell\u00a0(1st\u00a0Gen)",
+          "CHIP": "GM108",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 0,
+          "Total # of NDEC": 0,
+          "MPEG-1": false,
+          "MPEG-2": false,
+          "VC-1": false,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
+          "h264": false,
+          "hevc": false
+        },
+        "GeForce MX110 / MX130": {
+          "BOARD": "GeForce MX110 / MX130",
+          "FAMILY": "Maxwell\u00a0(1st\u00a0Gen)",
+          "CHIP": "GM108",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 0,
+          "Total # of NDEC": 0,
+          "MPEG-1": false,
+          "MPEG-2": false,
+          "VC-1": false,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
+          "h264": false,
+          "hevc": false
+        },
+        "GeForce GTX 750 GeForce GTX 950 - 960": {
+          "BOARD": "GeForce GTX 750 GeForce GTX 950 - 960",
+          "FAMILY": "Maxwell\u00a0(2nd\u00a0Gen)",
+          "CHIP": "GM206",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": true,
+          "VP9 8\u00a0bit": true,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": true,
+          "vp9": true,
+          "h264": true,
+          "hevc": true
+        },
+        "GeForce GTX 965M": {
+          "BOARD": "GeForce GTX 965M",
+          "FAMILY": "Maxwell\u00a0(2nd\u00a0Gen)",
+          "CHIP": "GM206",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": true,
+          "VP9 8\u00a0bit": true,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": true,
+          "vp9": true,
+          "h264": true,
+          "hevc": true
+        },
+        "GeForce GTX 910M / 920M / 920A": {
+          "BOARD": "GeForce GTX 910M / 920M / 920A",
+          "FAMILY": "Maxwell\u00a0(2nd\u00a0Gen)",
+          "CHIP": "GM208B",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GeForce GTX 965M > 980M / 980MX": {
+          "BOARD": "GeForce GTX 965M > 980M / 980MX",
+          "FAMILY": "Maxwell\u00a0(2nd\u00a0Gen)",
+          "CHIP": "GM204",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": true,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": true,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GeForce GTX 960 Ti / 970 / 980": {
+          "BOARD": "GeForce GTX 960 Ti / 970 / 980",
+          "FAMILY": "Maxwell\u00a0(2nd\u00a0Gen)",
+          "CHIP": "GM204",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": true,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": true,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GeForce GTX 980 Ti": {
+          "BOARD": "GeForce GTX 980 Ti",
+          "FAMILY": "Maxwell\u00a0(2nd\u00a0Gen)",
+          "CHIP": "GM200",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": true,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": true,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GeForce GTX Titan X": {
+          "BOARD": "GeForce GTX Titan X",
+          "FAMILY": "Maxwell\u00a0(2nd\u00a0Gen)",
+          "CHIP": "GM200",
+          "Desktop/Mobile/Server": "D",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": true,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": true,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GeForce MX150": {
+          "BOARD": "GeForce MX150",
+          "FAMILY": "Pascal",
+          "CHIP": "GP108",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 0,
+          "Total # of NDEC": 0,
+          "MPEG-1": false,
+          "MPEG-2": false,
+          "VC-1": false,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
+          "h264": false,
+          "hevc": false
+        },
+        "GeForce MX230 / MX250": {
+          "BOARD": "GeForce MX230 / MX250",
+          "FAMILY": "Pascal",
+          "CHIP": "GP108",
+          "Desktop/Mobile/Server": "M",
+          "# OF CHIPS": 1,
+          "# OF NVDEC/CHIP": 0,
+          "Total # of NDEC": 0,
+          "MPEG-1": false,
+          "MPEG-2": false,
+          "VC-1": false,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
+          "h264": false,
+          "hevc": false
+        },
+        "Quadro K420 / K600": {
+          "BOARD": "Quadro K420 / K600",
+          "FAMILY": "Kepler",
+          "CHIP": "GK107",
+          "# OF CHIPS": "D",
+          "Desktop/Mobile/Server": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "Quadro K2000 / K2000D": {
+          "BOARD": "Quadro K2000 / K2000D",
+          "FAMILY": "Kepler",
+          "CHIP": "GK107",
+          "# OF CHIPS": "D",
+          "Desktop/Mobile/Server": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "Quadro K2100 > K5100": {
+          "BOARD": "Quadro K2100 > K5100",
+          "FAMILY": "Kepler",
+          "CHIP": "GK106",
+          "# OF CHIPS": "M",
+          "Desktop/Mobile/Server": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "Quadro K4000": {
+          "BOARD": "Quadro K4000",
+          "FAMILY": "Kepler",
+          "CHIP": "GK106",
+          "# OF CHIPS": "D",
+          "Desktop/Mobile/Server": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "Quadro K100 > K2000 + K5100": {
+          "BOARD": "Quadro K100 > K2000 + K5100",
+          "FAMILY": "Kepler",
+          "CHIP": "GK104",
+          "# OF CHIPS": "M",
+          "Desktop/Mobile/Server": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "Quadro K4200 / K5000": {
+          "BOARD": "Quadro K4200 / K5000",
+          "FAMILY": "Kepler",
+          "CHIP": "GK104",
+          "# OF CHIPS": "D",
+          "Desktop/Mobile/Server": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "Quadro K5200 / K6000": {
+          "BOARD": "Quadro K5200 / K6000",
+          "FAMILY": "Kepler\u00a0(2nd Gen)",
+          "CHIP": "GK110B",
+          "# OF CHIPS": "D",
+          "Desktop/Mobile/Server": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "Quadro K620 / K1200": {
+          "BOARD": "Quadro K620 / K1200",
+          "FAMILY": "Maxwell\u00a0(1st Gen)",
+          "CHIP": "GM107",
+          "# OF CHIPS": "D",
+          "Desktop/Mobile/Server": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "Quadro K2200": {
+          "BOARD": "Quadro K2200",
+          "FAMILY": "Maxwell\u00a0(1st Gen)",
+          "CHIP": "GM107",
+          "# OF CHIPS": "D",
+          "Desktop/Mobile/Server": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "Quadro M500 / M520": {
+          "BOARD": "Quadro M500 / M520",
+          "FAMILY": "Maxwell\u00a0(1st Gen)",
+          "CHIP": "GM108",
+          "# OF CHIPS": "M",
+          "Desktop/Mobile/Server": 1,
+          "# OF NVDEC/CHIP": 0,
+          "Total # of NDEC": 0,
+          "MPEG-1": false,
+          "MPEG-2": false,
+          "VC-1": false,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
+          "h264": false,
+          "hevc": false
+        },
+        "Quadro M600 / M620": {
+          "BOARD": "Quadro M600 / M620",
+          "FAMILY": "Maxwell\u00a0(1st Gen)",
+          "CHIP": "GM107",
+          "# OF CHIPS": "M",
+          "Desktop/Mobile/Server": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "Quadro M1000 / M1200 / M2000": {
+          "BOARD": "Quadro M1000 / M1200 / M2000",
+          "FAMILY": "Maxwell\u00a0(1st Gen)",
+          "CHIP": "GM107",
+          "# OF CHIPS": "M",
+          "Desktop/Mobile/Server": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "Quadro M2000": {
+          "BOARD": "Quadro M2000",
+          "FAMILY": "Maxwell\u00a0(GM206)",
+          "CHIP": "GM206",
+          "# OF CHIPS": "D",
+          "Desktop/Mobile/Server": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": true,
+          "VP9 8\u00a0bit": true,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": true,
+          "vp9": true,
+          "h264": true,
+          "hevc": true
+        },
+        "Quadro M2200": {
+          "BOARD": "Quadro M2200",
+          "FAMILY": "Maxwell\u00a0(GM206)",
+          "CHIP": "GM206",
+          "# OF CHIPS": "M",
+          "Desktop/Mobile/Server": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": true,
+          "VP9 8\u00a0bit": true,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": true,
+          "vp9": true,
+          "h264": true,
+          "hevc": true
+        },
+        "Quadro M3000 / M4000 / M5500": {
+          "BOARD": "Quadro M3000 / M4000 / M5500",
+          "FAMILY": "Maxwell\u00a0(2nd Gen)",
+          "CHIP": "GM204",
+          "# OF CHIPS": "M",
+          "Desktop/Mobile/Server": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": true,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": true,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "Quadro M4000 / M5000": {
+          "BOARD": "Quadro M4000 / M5000",
+          "FAMILY": "Maxwell\u00a0(2nd Gen)",
+          "CHIP": "GM204",
+          "# OF CHIPS": "D",
+          "Desktop/Mobile/Server": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": true,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": true,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "Quadro M6000": {
+          "BOARD": "Quadro M6000",
+          "FAMILY": "Maxwell\u00a0(2nd Gen)",
+          "CHIP": "GM200",
+          "# OF CHIPS": "D",
+          "Desktop/Mobile/Server": 1,
+          "# OF NVDEC/CHIP": 1,
+          "Total # of NDEC": 1,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": true,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": true,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GRID K1": {
+          "BOARD": "GRID K1",
+          "FAMILY": "Kepler",
+          "CHIP": "GK107",
+          "# OF CHIPS": 4.0,
+          "# OF NVDEC/CHIP": 1.0,
+          "Total # of NDEC": 4.0,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GRID K2": {
+          "BOARD": "GRID K2",
+          "FAMILY": "Kepler",
+          "CHIP": "GK104",
+          "# OF CHIPS": 2.0,
+          "# OF NVDEC/CHIP": 1.0,
+          "Total # of NDEC": 2.0,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GRID K340": {
+          "BOARD": "GRID K340",
+          "FAMILY": "Kepler",
+          "CHIP": "GK107",
+          "# OF CHIPS": 4.0,
+          "# OF NVDEC/CHIP": 1.0,
+          "Total # of NDEC": 4.0,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "GRID K520": {
+          "BOARD": "GRID K520",
+          "FAMILY": "Kepler",
+          "CHIP": "GK104",
+          "# OF CHIPS": 2.0,
+          "# OF NVDEC/CHIP": 1.0,
+          "Total # of NDEC": 2.0,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "Tesla K10": {
+          "BOARD": "Tesla K10",
+          "FAMILY": "Kepler",
+          "CHIP": "GK104",
+          "# OF CHIPS": 2.0,
+          "# OF NVDEC/CHIP": 1.0,
+          "Total # of NDEC": 2.0,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "Tesla K20X": {
+          "BOARD": "Tesla K20X",
+          "FAMILY": "Kepler",
+          "CHIP": "GK110",
+          "# OF CHIPS": 1.0,
+          "# OF NVDEC/CHIP": 1.0,
+          "Total # of NDEC": 1.0,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "Tesla K40": {
+          "BOARD": "Tesla K40",
+          "FAMILY": "Kepler",
+          "CHIP": "GK110B",
+          "# OF CHIPS": 1.0,
+          "# OF NVDEC/CHIP": 1.0,
+          "Total # of NDEC": 1.0,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "Tesla K80": {
+          "BOARD": "Tesla K80",
+          "FAMILY": "Kepler\u00a0(2nd Gen)",
+          "CHIP": "GK210",
+          "# OF CHIPS": 2.0,
+          "# OF NVDEC/CHIP": 1.0,
+          "Total # of NDEC": 2.0,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": false,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": false,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "Tesla M10": {
+          "BOARD": "Tesla M10",
+          "FAMILY": "Maxwell\u00a0(1st Gen)",
+          "CHIP": "GM107",
+          "# OF CHIPS": 4.0,
+          "# OF NVDEC/CHIP": 1.0,
+          "Total # of NDEC": 4.0,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": true,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": true,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "Tesla M4": {
+          "BOARD": "Tesla M4",
+          "FAMILY": "Maxwell\u00a0(GM206)",
+          "CHIP": "GM206",
+          "# OF CHIPS": 1.0,
+          "# OF NVDEC/CHIP": 1.0,
+          "Total # of NDEC": 1.0,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": true,
+          "VP9 8\u00a0bit": true,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": true,
+          "vp9": true,
+          "h264": true,
+          "hevc": true
+        },
+        "Tesla M6": {
+          "BOARD": "Tesla M6",
+          "FAMILY": "Maxwell\u00a0(2nd Gen)",
+          "CHIP": "GM204",
+          "# OF CHIPS": 1.0,
+          "# OF NVDEC/CHIP": 1.0,
+          "Total # of NDEC": 1.0,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": true,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": true,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "Tesla M60": {
+          "BOARD": "Tesla M60",
+          "FAMILY": "Maxwell\u00a0(2nd Gen)",
+          "CHIP": "GM204",
+          "# OF CHIPS": 2.0,
+          "# OF NVDEC/CHIP": 1.0,
+          "Total # of NDEC": 2.0,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": true,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": true,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        },
+        "Tesla M40": {
+          "BOARD": "Tesla M40",
+          "FAMILY": "Maxwell\u00a0(2nd Gen)",
+          "CHIP": "GM200",
+          "# OF CHIPS": 1.0,
+          "# OF NVDEC/CHIP": 1.0,
+          "Total # of NDEC": 1.0,
+          "MPEG-1": true,
+          "MPEG-2": true,
+          "VC-1": true,
+          "VP8": true,
+          "VP9 8\u00a0bit": false,
+          "VP9 10\u00a0bit": false,
+          "VP9 12\u00a0bit": false,
+          "H.264(AVCHD)": true,
+          "H.265\u00a0(HEVC)\u00a04:2:0 8\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 10\u00a0bit": false,
+          "H.265\u00a0(HEVC)\u00a04:2:0 12\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 8\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 10\u00a0bit": false,
+          "*H.265\u00a0(HEVC)\u00a04:4:4 12\u00a0bit": false,
+          "mpeg1video": true,
+          "mpeg2video": true,
+          "vc1": true,
+          "vp8": true,
+          "vp9": false,
+          "h264": true,
+          "hevc": false
+        }
       }
     }
   }

From 054aadb56c3ab65e88e7b8bde5b2e2cfbbe42fba Mon Sep 17 00:00:00 2001
From: Ross Patterson <me@rpatterson.net>
Date: Sat, 10 Aug 2019 18:15:51 -0700
Subject: [PATCH 28/37] Detect: Cleanup redundant variable assignment

---
 ffmpeg/_detect.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/ffmpeg/_detect.py b/ffmpeg/_detect.py
index 0cc5bed9..e776be2f 100644
--- a/ffmpeg/_detect.py
+++ b/ffmpeg/_detect.py
@@ -192,7 +192,6 @@ def detect_codecs(decoder, encoder, hwaccels=None, cmd='ffmpeg'):
                     encoder, {}).get('encoders', []):
                 # We have an accelerated encoder, include it.
                 # Remove hwaccel codecs from future consideration.
-                hwaccel_encoder = hwaccel_encoder
                 avail_encoders.remove(hwaccel_encoder)
                 hwaccel_kwargs = collections.OrderedDict(
                     input=collections.OrderedDict(hwaccel=hwaccel['name']),

From d3ac1865a42f34400451d1a989713039509a805b Mon Sep 17 00:00:00 2001
From: Ross Patterson <me@rpatterson.net>
Date: Sat, 10 Aug 2019 18:39:21 -0700
Subject: [PATCH 29/37] Detect: Integrate GPU codecs data into the GPU
 detection

---
 ffmpeg/_detect.py | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/ffmpeg/_detect.py b/ffmpeg/_detect.py
index e776be2f..09918b4d 100644
--- a/ffmpeg/_detect.py
+++ b/ffmpeg/_detect.py
@@ -117,6 +117,7 @@ def detect_gpus():
     for gpu in gpus:
         vendor_data = data.get(gpu.get('vendor', '').lower())
         if vendor_data:
+
             model_lines_data = _parse_models(
                 model_lines=vendor_data['lines'],
                 boards=gpu['board'].lower(), model_data={})
@@ -124,6 +125,23 @@ def detect_gpus():
             gpu['model_num'] = list(model_lines_data[
                 gpu['model_line']]['models'].keys())[0]
 
+            for coder_type in ['encoders', 'decoders']:
+                model_line_data = vendor_data[coder_type]['model_lines'][
+                    gpu['model_line']]
+                coder_boards = model_line_data['models'].get(
+                    gpu['model_num'])
+                if coder_boards is None:
+                    for model_range, boards in model_line_data[
+                            'model_ranges']:
+                        # TODO proper model range matching
+                        if gpu['model_num'] in model_range:
+                            coder_boards = boards
+                            break
+                if coder_boards is None:
+                    continue
+                gpu[coder_type] = vendor_data[coder_type]['boards'][
+                    coder_boards]
+
     return gpus
 
 

From 267bb71fd6449eb94516361561c2b6dd25a5f40d Mon Sep 17 00:00:00 2001
From: Ross Patterson <me@rpatterson.net>
Date: Sat, 10 Aug 2019 19:16:44 -0700
Subject: [PATCH 30/37] Detect: NVidia, assume encoding not supported for
 absent codecs

---
 examples/get_detect_data.py |   4 +
 ffmpeg/detect.json          | 480 ++++++++++++++++++++++++++++++++++++
 2 files changed, 484 insertions(+)

diff --git a/examples/get_detect_data.py b/examples/get_detect_data.py
index 20b76d75..41a70cef 100755
--- a/examples/get_detect_data.py
+++ b/examples/get_detect_data.py
@@ -138,6 +138,10 @@ def get_nvidia_data():
                             model_data[codec] = nv_coder_row[
                                 column_idx] == 'YES'
                             break
+                    else:
+                        # Assume encoder support is not available
+                        model_data[codec] = False
+
                 coder_data['boards'][model_data['BOARD']] = model_data
 
                 _detect._parse_models(
diff --git a/ffmpeg/detect.json b/ffmpeg/detect.json
index e207a46c..d66423ac 100644
--- a/ffmpeg/detect.json
+++ b/ffmpeg/detect.json
@@ -347,6 +347,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": false,
           "hevc": false
         },
@@ -367,6 +372,11 @@
           "H.265 (HEVC) 4K Lossless": true,
           "H.265 (HEVC) 8k": true,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -387,6 +397,11 @@
           "H.265 (HEVC) 4K Lossless": true,
           "H.265 (HEVC) 8k": true,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -407,6 +422,11 @@
           "H.265 (HEVC) 4K Lossless": true,
           "H.265 (HEVC) 8k": true,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -427,6 +447,11 @@
           "H.265 (HEVC) 4K Lossless": true,
           "H.265 (HEVC) 8k": true,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -447,6 +472,11 @@
           "H.265 (HEVC) 4K Lossless": true,
           "H.265 (HEVC) 8k": true,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -467,6 +497,11 @@
           "H.265 (HEVC) 4K Lossless": true,
           "H.265 (HEVC) 8k": true,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -487,6 +522,11 @@
           "H.265 (HEVC) 4K Lossless": true,
           "H.265 (HEVC) 8k": true,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -507,6 +547,11 @@
           "H.265 (HEVC) 4K Lossless": true,
           "H.265 (HEVC) 8k": true,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -527,6 +572,11 @@
           "H.265 (HEVC) 4K Lossless": true,
           "H.265 (HEVC) 8k": true,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -547,6 +597,11 @@
           "H.265 (HEVC) 4K Lossless": true,
           "H.265 (HEVC) 8k": true,
           "HEVC B Frame support": true,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -567,6 +622,11 @@
           "H.265 (HEVC) 4K Lossless": true,
           "H.265 (HEVC) 8k": true,
           "HEVC B Frame support": true,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -587,6 +647,11 @@
           "H.265 (HEVC) 4K Lossless": true,
           "H.265 (HEVC) 8k": true,
           "HEVC B Frame support": true,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -607,6 +672,11 @@
           "H.265 (HEVC) 4K Lossless": true,
           "H.265 (HEVC) 8k": true,
           "HEVC B Frame support": true,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -627,6 +697,11 @@
           "H.265 (HEVC) 4K Lossless": true,
           "H.265 (HEVC) 8k": true,
           "HEVC B Frame support": true,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -647,6 +722,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": false,
           "hevc": false
         },
@@ -667,6 +747,11 @@
           "H.265 (HEVC) 4K Lossless": true,
           "H.265 (HEVC) 8k": true,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -687,6 +772,11 @@
           "H.265 (HEVC) 4K Lossless": true,
           "H.265 (HEVC) 8k": true,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -707,6 +797,11 @@
           "H.265 (HEVC) 4K Lossless": true,
           "H.265 (HEVC) 8k": true,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -727,6 +822,11 @@
           "H.265 (HEVC) 4K Lossless": true,
           "H.265 (HEVC) 8k": true,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -747,6 +847,11 @@
           "H.265 (HEVC) 4K Lossless": true,
           "H.265 (HEVC) 8k": true,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -767,6 +872,11 @@
           "H.265 (HEVC) 4K Lossless": true,
           "H.265 (HEVC) 8k": true,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -787,6 +897,11 @@
           "H.265 (HEVC) 4K Lossless": true,
           "H.265 (HEVC) 8k": true,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -807,6 +922,11 @@
           "H.265 (HEVC) 4K Lossless": true,
           "H.265 (HEVC) 8k": true,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -827,6 +947,11 @@
           "H.265 (HEVC) 4K Lossless": true,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -847,6 +972,11 @@
           "H.265 (HEVC) 4K Lossless": true,
           "H.265 (HEVC) 8k": true,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -867,6 +997,11 @@
           "H.265 (HEVC) 4K Lossless": true,
           "H.265 (HEVC) 8k": true,
           "HEVC B Frame support": true,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -887,6 +1022,11 @@
           "H.265 (HEVC) 4K Lossless": true,
           "H.265 (HEVC) 8k": true,
           "HEVC B Frame support": true,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -907,6 +1047,11 @@
           "H.265 (HEVC) 4K Lossless": true,
           "H.265 (HEVC) 8k": true,
           "HEVC B Frame support": true,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -927,6 +1072,11 @@
           "H.265 (HEVC) 4K Lossless": true,
           "H.265 (HEVC) 8k": true,
           "HEVC B Frame support": true,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -947,6 +1097,11 @@
           "H.265 (HEVC) 4K Lossless": true,
           "H.265 (HEVC) 8k": true,
           "HEVC B Frame support": true,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -967,6 +1122,11 @@
           "H.265 (HEVC) 4K Lossless": true,
           "H.265 (HEVC) 8k": true,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -986,6 +1146,11 @@
           "H.265 (HEVC) 4K Lossless": true,
           "H.265 (HEVC) 8k": true,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -1005,6 +1170,11 @@
           "H.265 (HEVC) 4K Lossless": true,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -1024,6 +1194,11 @@
           "H.265 (HEVC) 4K Lossless": true,
           "H.265 (HEVC) 8k": true,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -1043,6 +1218,11 @@
           "H.265 (HEVC) 4K Lossless": true,
           "H.265 (HEVC) 8k": true,
           "HEVC B Frame support": true,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -1063,6 +1243,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": false
         },
@@ -1083,6 +1268,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": false
         },
@@ -1103,6 +1293,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": false
         },
@@ -1123,6 +1318,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": false
         },
@@ -1143,6 +1343,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": false
         },
@@ -1163,6 +1368,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": false
         },
@@ -1183,6 +1393,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": false
         },
@@ -1203,6 +1418,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": false
         },
@@ -1223,6 +1443,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": false
         },
@@ -1243,6 +1468,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": false
         },
@@ -1263,6 +1493,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": false
         },
@@ -1283,6 +1518,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": false
         },
@@ -1303,6 +1543,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": false
         },
@@ -1323,6 +1568,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": false
         },
@@ -1343,6 +1593,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": false
         },
@@ -1363,6 +1618,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": false
         },
@@ -1383,6 +1643,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": false,
           "hevc": false
         },
@@ -1403,6 +1668,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": false,
           "hevc": false
         },
@@ -1423,6 +1693,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": false,
           "hevc": false
         },
@@ -1443,6 +1718,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": false,
           "hevc": false
         },
@@ -1463,6 +1743,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -1483,6 +1768,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -1503,6 +1793,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": false
         },
@@ -1523,6 +1818,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -1543,6 +1843,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -1563,6 +1868,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -1583,6 +1893,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -1603,6 +1918,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": false,
           "hevc": false
         },
@@ -1623,6 +1943,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": false
         },
@@ -1643,6 +1968,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": false
         },
@@ -1663,6 +1993,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": false
         },
@@ -1683,6 +2018,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": false
         },
@@ -1703,6 +2043,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": false
         },
@@ -1723,6 +2068,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": false
         },
@@ -1743,6 +2093,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": false
         },
@@ -1763,6 +2118,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": false
         },
@@ -1783,6 +2143,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": false
         },
@@ -1803,6 +2168,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": false,
           "hevc": false
         },
@@ -1823,6 +2193,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": false
         },
@@ -1843,6 +2218,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": false
         },
@@ -1863,6 +2243,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -1883,6 +2268,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -1903,6 +2293,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -1923,6 +2318,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -1943,6 +2343,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -1962,6 +2367,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": false
         },
@@ -1981,6 +2391,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": false
         },
@@ -2000,6 +2415,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": false
         },
@@ -2019,6 +2439,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": false
         },
@@ -2038,6 +2463,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": false
         },
@@ -2057,6 +2487,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": false
         },
@@ -2076,6 +2511,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": false
         },
@@ -2095,6 +2535,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": false
         },
@@ -2114,6 +2559,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": false
         },
@@ -2133,6 +2583,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -2152,6 +2607,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -2171,6 +2631,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -2190,6 +2655,11 @@
           "H.265 (HEVC) 4K Lossless": false,
           "H.265 (HEVC) 8k": false,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -2209,6 +2679,11 @@
           "H.265 (HEVC) 4K Lossless": true,
           "H.265 (HEVC) 8k": true,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         },
@@ -2228,6 +2703,11 @@
           "H.265 (HEVC) 4K Lossless": true,
           "H.265 (HEVC) 8k": true,
           "HEVC B Frame support": false,
+          "mpeg1video": false,
+          "mpeg2video": false,
+          "vc1": false,
+          "vp8": false,
+          "vp9": false,
           "h264": true,
           "hevc": true
         }

From 47cc498aa60dac8b5020780ac61b1f602a45c943 Mon Sep 17 00:00:00 2001
From: Ross Patterson <me@rpatterson.net>
Date: Sat, 10 Aug 2019 19:17:42 -0700
Subject: [PATCH 31/37] Detect: Filter encoders and decoders based on GPU
 support

---
 ffmpeg/_detect.py | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/ffmpeg/_detect.py b/ffmpeg/_detect.py
index 09918b4d..ce9327b8 100644
--- a/ffmpeg/_detect.py
+++ b/ffmpeg/_detect.py
@@ -171,6 +171,23 @@ def detect_hwaccels(hwaccels=None, cmd='ffmpeg'):
     hwaccels = [
         hwaccel for hwaccel in hwaccels if hwaccel['name'] in api_avail]
 
+    # Filter encoders and decoders based on what's supported by the GPU
+    for gpu in gpus:
+        for coder_type in ['encoders', 'decoders']:
+            coder_data = gpu.get(coder_type)
+            if coder_data is None:
+                continue
+            for hwaccel in hwaccels:
+                for codec, coders in hwaccel.get('codecs', {}).items():
+                    coder_supported = coder_data.get(codec)
+                    if coder_supported is None or coder_supported:
+                        # This encoder/decoder is supported, no need to filter
+                        # it out
+                        continue
+
+                    # This codec isn't supported by the GPU hjardware
+                    coders.pop(coder_type, None)
+
     hwaccels.sort(key=lambda hwaccel: (
         # Sort unranked hwaccels last, but in the order given by ffmpeg
         hwaccel['name'] in HWACCELS_BY_PERFORMANCE and 1 or 0,
@@ -178,6 +195,7 @@ def detect_hwaccels(hwaccels=None, cmd='ffmpeg'):
             # Sort ranked hwaccels per the constant
             hwaccel['name'] in HWACCELS_BY_PERFORMANCE and
             HWACCELS_BY_PERFORMANCE.index(hwaccel['name']))))
+
     hwaccels_data['hwaccels'] = hwaccels
     return hwaccels_data
 

From c04c2e9c35cc22420f312d57b09f14110039552d Mon Sep 17 00:00:00 2001
From: Ross Patterson <me@rpatterson.net>
Date: Sun, 11 Aug 2019 20:36:41 -0700
Subject: [PATCH 32/37] Detect: Sometimes encoders work when not listed in
 `ffmpeg -codecs`

---
 ffmpeg/_detect.py | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

diff --git a/ffmpeg/_detect.py b/ffmpeg/_detect.py
index ce9327b8..e64d1688 100644
--- a/ffmpeg/_detect.py
+++ b/ffmpeg/_detect.py
@@ -210,16 +210,12 @@ def detect_codecs(decoder, encoder, hwaccels=None, cmd='ffmpeg'):
 
     avail_decoders = build_codecs.get(decoder, {}).get('decoders', [])
     avail_encoders = build_codecs.get(encoder, {}).get('encoders', [])
-    if not avail_decoders:
-        raise ValueError(
-            'Could not detect a supported decoder for {0!r}'.format(decoder))
-    if not avail_encoders:
-        raise ValueError(
-            'Could not detect a supported encoder for {0!r}'.format(encoder))
 
     codecs_kwargs = []
     default_kwargs = collections.OrderedDict(
-        output=collections.OrderedDict(codec=avail_encoders[0]))
+        output=collections.OrderedDict())
+    if avail_encoders:
+        default_kwargs['output']['codec'] = avail_encoders[0]
     for hwaccel in hwaccels_data['hwaccels']:
 
         if hwaccel['codecs']:

From 89464c8f82ea3532a2e467b49d142906c5fa0f3a Mon Sep 17 00:00:00 2001
From: Ross Patterson <me@rpatterson.net>
Date: Mon, 12 Aug 2019 01:07:22 -0700
Subject: [PATCH 33/37] Windows: Fix newline differences

---
 ffmpeg/_build.py            |  7 ++++---
 ffmpeg/_detect.py           |  4 ++--
 ffmpeg/_probe.py            |  7 ++++---
 ffmpeg/tests/test_ffmpeg.py | 12 ++++++++----
 4 files changed, 18 insertions(+), 12 deletions(-)

diff --git a/ffmpeg/_build.py b/ffmpeg/_build.py
index d75d17f8..3b6192c0 100644
--- a/ffmpeg/_build.py
+++ b/ffmpeg/_build.py
@@ -63,13 +63,14 @@ def _run(args):
     Run the command and return stdout but only print stderr on failure.
     """
     process = subprocess.Popen(
-        args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        args, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+        universal_newlines=True)
     stdout, stderr = process.communicate()
     if process.returncode != 0:
-        logger.error(stderr.decode())
+        logger.error(stderr)
         raise subprocess.CalledProcessError(
             process.returncode, process.args, output=stdout, stderr=stderr)
-    return stdout.decode()
+    return stdout
 
 
 def _get_line_fields(
diff --git a/ffmpeg/_detect.py b/ffmpeg/_detect.py
index e64d1688..463174a3 100644
--- a/ffmpeg/_detect.py
+++ b/ffmpeg/_detect.py
@@ -75,9 +75,9 @@ def detect_gpus():
     if plat_sys == 'Linux':
         # TODO: Android and other Linux'es that don't have `lshw`
         display_output = subprocess.check_output(
-            ['lshw', '-class', 'display', '-json'])
+            ['lshw', '-class', 'display', '-json'], universal_newlines=True)
         displays_data = json.loads(
-            display_output.decode().strip().strip(','),
+            display_output.strip().strip(','),
             object_pairs_hook=collections.OrderedDict)
         if not isinstance(displays_data, list):
             # TODO: Confirm this is how `lshw` handles multiple GPUs
diff --git a/ffmpeg/_probe.py b/ffmpeg/_probe.py
index be25d4bd..ec8f1374 100644
--- a/ffmpeg/_probe.py
+++ b/ffmpeg/_probe.py
@@ -22,12 +22,13 @@ def probe(filename, cmd='ffprobe', **kwargs):
     args += convert_kwargs_to_cmd_line_args(kwargs)
     args += [filename]
 
-    p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    p = subprocess.Popen(
+        args, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+        universal_newlines=True)
     out, err = p.communicate()
     if p.returncode != 0:
         raise Error('ffprobe', out, err)
-    return json.loads(
-        out.decode('utf-8'), object_pairs_hook=collections.OrderedDict)
+    return json.loads(out, object_pairs_hook=collections.OrderedDict)
 
 
 __all__ = ['probe']
diff --git a/ffmpeg/tests/test_ffmpeg.py b/ffmpeg/tests/test_ffmpeg.py
index e27b4e64..73909173 100644
--- a/ffmpeg/tests/test_ffmpeg.py
+++ b/ffmpeg/tests/test_ffmpeg.py
@@ -9,6 +9,8 @@
 import re
 import subprocess
 
+import six
+
 try:
     import mock  # python 2
 except ImportError:
@@ -710,7 +712,7 @@ def test__probe__exception():
     with pytest.raises(ffmpeg.Error) as excinfo:
         ffmpeg.probe(BOGUS_INPUT_FILE)
     assert str(excinfo.value) == 'ffprobe error (see stderr output for detail)'
-    assert 'No such file or directory'.encode() in excinfo.value.stderr
+    assert 'No such file or directory' in excinfo.value.stderr
 
 
 def test__probe__extra_args():
@@ -725,11 +727,11 @@ def test__build_data():
         'protocols', 'filters', 'pix_fmts', 'sample_fmts', 'layouts',
         'colors', 'devices', 'hw_devices', 'hwaccels'}
 
-    assert isinstance(data['version'], str)
+    assert isinstance(data['version'], six.string_types)
 
     assert isinstance(data['codecs'], dict)
     for codec, coders in data['codecs'].items():
-        assert isinstance(codec, str)
+        assert isinstance(codec, six.string_types)
         assert isinstance(coders, dict)
     assert isinstance(data['hwaccels'], list)
     for hwaccel in data['hwaccels']:
@@ -766,7 +768,9 @@ def test__detect():
             assert 'output' in codec_kwargs
             assert isinstance(codec_kwargs['output'], dict)
             assert 'codec' in codec_kwargs['output']
-            assert isinstance(codec_kwargs['output']['codec'], str)
+            assert isinstance(
+                codec_kwargs['output']['codec'],
+                six.string_types)
 
 
 def test__detect_parse_models():

From 96d4d490b11b1205af055dda711887c4d14fe3d9 Mon Sep 17 00:00:00 2001
From: Ross Patterson <me@rpatterson.net>
Date: Mon, 12 Aug 2019 01:07:40 -0700
Subject: [PATCH 34/37] Detect: Fix handling of GPUs not listed in hwaccel APIs

For example, Windows remote desktop
---
 ffmpeg/_detect.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/ffmpeg/_detect.py b/ffmpeg/_detect.py
index 463174a3..e2e8316c 100644
--- a/ffmpeg/_detect.py
+++ b/ffmpeg/_detect.py
@@ -166,8 +166,10 @@ def detect_hwaccels(hwaccels=None, cmd='ffmpeg'):
     gpus = detect_gpus()
     api_avail = set()
     for gpu in gpus:
-        api_avail.update(
-            data['hwaccels']['api_avail'][plat_sys][gpu['vendor']])
+        vendor_apis = data['hwaccels']['api_avail'][plat_sys].get(
+            gpu['vendor'])
+        if vendor_apis:
+            api_avail.update(vendor_apis)
     hwaccels = [
         hwaccel for hwaccel in hwaccels if hwaccel['name'] in api_avail]
 

From aba5a5781cf55b6f49bba717bc548083fd3d2722 Mon Sep 17 00:00:00 2001
From: Ross Patterson <me@rpatterson.net>
Date: Mon, 12 Aug 2019 01:11:37 -0700
Subject: [PATCH 35/37] Project: Ignore Python and editor artifacts

---
 .gitignore | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/.gitignore b/.gitignore
index 780f20e4..88a20fbf 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,5 @@
+*.py[co]
+
 .cache
 .eggs
 .tox/
@@ -6,3 +8,5 @@ ffmpeg/tests/sample_data/out*.mp4
 ffmpeg_python.egg-info/
 venv*
 build/
+
+*~
\ No newline at end of file

From 94b8333ddd5a99bae9822db5f7c4af8e56bb8f2e Mon Sep 17 00:00:00 2001
From: Ross Patterson <me@rpatterson.net>
Date: Mon, 12 Aug 2019 13:50:11 -0700
Subject: [PATCH 36/37] Build/Detect: Clarify constants organization

---
 ffmpeg/_build.py  | 107 ++++++++++++++++++++++++----------------------
 ffmpeg/_detect.py |  50 +++++++++++-----------
 2 files changed, 83 insertions(+), 74 deletions(-)

diff --git a/ffmpeg/_build.py b/ffmpeg/_build.py
index 3b6192c0..8e2521c8 100644
--- a/ffmpeg/_build.py
+++ b/ffmpeg/_build.py
@@ -17,45 +17,51 @@
     help='The path to the ffmpeg execuatble')
 
 
-VERSION_RE = re.compile(r' version (?P<version>[^ ]+) ')
-
-MUXER_RE = re.compile(
-    r'^ (?P<demuxing>[D ])(?P<muxing>[E ]) '
-    r'(?P<name>[^ ]+) +(?P<description>.+)$',
-    re.M)
-MUXER_FLAGS = dict(demuxing='D', muxing='E')
-
-CODEC_RE = re.compile(
-    r'^ (?P<decoding>[D.])(?P<encoding>[E.])'
-    r'(?P<stream>[VAS.])(?P<intra_frame>[I.])'
-    r'(?P<lossy>[L.])(?P<lossless>[S.]) '
-    r'(?P<name>[^ ]+) +(?P<description>.+)$',
-    re.M)
-CODEC_FLAGS = dict(
-    decoding='D', encoding='E',
-    stream=dict(video='V', audio='A', subtitle='S'),
-    intra_frame='I', lossy='L', lossless='S')
-CODEC_DESCRIPTION_RE = re.compile(
-    r'^(?P<description>.+?) \((de|en)coders: [^)]+ \)')
-CODEC_CODERS_RE = re.compile(
-    r' \((?P<type>(de|en)coders): (?P<coders>[^)]+) \)')
-
-HWACCEL_SYNONYMS = dict(cuvid=['nvenc', 'nvdec', 'cuda'])
-
-FILTER_RE = re.compile(
-    r'^ (?P<timeline>[T.])(?P<slice>[S.])(?P<command>[C.]) '
-    r'(?P<name>[^ ]+) +(?P<io>[^ ]+) +(?P<description>.+)$',
-    re.M)
-FILTER_FLAGS = dict(timeline='T', slice='S', command='C')
-
-PIX_FMT_RE = re.compile(
-    r'^(?P<input>[I.])(?P<output>[O.])(?P<accelerated>[H.])'
-    r'(?P<palleted>[P.])(?P<bitstream>[B.]) '
-    r'(?P<name>[^ ]+) +(?P<components>[0-9]+) +(?P<bits>[0-9]+)$',
-    re.M)
-PIX_FMT_FLAGS = dict(
-    input='I', output='O', accelerated='H', palleted='P', bitstream='B')
-PIX_FMT_INT_FIELDS = {'components', 'bits'}
+VERSION = dict(
+    RE=re.compile(r' version (?P<version>[^ ]+) '))
+
+MUXER = dict(
+    RE=re.compile(
+        r'^ (?P<demuxing>[D ])(?P<muxing>[E ]) '
+        r'(?P<name>[^ ]+) +(?P<description>.+)$',
+        re.M),
+    FLAGS=dict(demuxing='D', muxing='E'))
+
+CODEC = dict(
+    RE=re.compile(
+        r'^ (?P<decoding>[D.])(?P<encoding>[E.])'
+        r'(?P<stream>[VAS.])(?P<intra_frame>[I.])'
+        r'(?P<lossy>[L.])(?P<lossless>[S.]) '
+        r'(?P<name>[^ ]+) +(?P<description>.+)$',
+        re.M),
+    FLAGS=dict(
+        decoding='D', encoding='E',
+        stream=dict(video='V', audio='A', subtitle='S'),
+        intra_frame='I', lossy='L', lossless='S'),
+    DESCRIPTION_RE=re.compile(
+        r'^(?P<description>.+?) \((de|en)coders: [^)]+ \)'),
+    CODERS_RE=re.compile(
+        r' \((?P<type>(de|en)coders): (?P<coders>[^)]+) \)'))
+
+HWACCEL = dict(
+    SYNONYMS=dict(cuvid=['nvenc', 'nvdec', 'cuda']))
+
+FILTER = dict(
+    RE=re.compile(
+        r'^ (?P<timeline>[T.])(?P<slice>[S.])(?P<command>[C.]) '
+        r'(?P<name>[^ ]+) +(?P<io>[^ ]+) +(?P<description>.+)$',
+        re.M),
+    FLAGS=dict(timeline='T', slice='S', command='C'))
+
+PIX_FMT = dict(
+    RE=re.compile(
+        r'^(?P<input>[I.])(?P<output>[O.])(?P<accelerated>[H.])'
+        r'(?P<palleted>[P.])(?P<bitstream>[B.]) '
+        r'(?P<name>[^ ]+) +(?P<components>[0-9]+) +(?P<bits>[0-9]+)$',
+        re.M),
+    FLAGS=dict(
+        input='I', output='O', accelerated='H', palleted='P', bitstream='B'),
+    INT_FIELDS={'components', 'bits'})
 
 
 def _run(args):
@@ -107,7 +113,7 @@ def get_version(cmd='ffmpeg'):
     Extract the version of the ffmpeg build.
     """
     stdout = _run([cmd, '-version'])
-    match = VERSION_RE.search(stdout.split('\n')[0])
+    match = VERSION['RE'].search(stdout.split('\n')[0])
     return match.group('version')
 
 
@@ -116,7 +122,7 @@ def get_formats(cmd='ffmpeg'):
     Extract the formats of the ffmpeg build.
     """
     stdout = _run([cmd, '-formats'])
-    return _get_line_fields(stdout, 4, MUXER_RE, MUXER_FLAGS)
+    return _get_line_fields(stdout, 4, MUXER['RE'], MUXER['FLAGS'])
 
 
 def get_demuxers(cmd='ffmpeg'):
@@ -124,7 +130,7 @@ def get_demuxers(cmd='ffmpeg'):
     Extract the demuxers of the ffmpeg build.
     """
     stdout = _run([cmd, '-demuxers'])
-    return _get_line_fields(stdout, 4, MUXER_RE, MUXER_FLAGS)
+    return _get_line_fields(stdout, 4, MUXER['RE'], MUXER['FLAGS'])
 
 
 def get_muxers(cmd='ffmpeg'):
@@ -132,7 +138,7 @@ def get_muxers(cmd='ffmpeg'):
     Extract the muxers of the ffmpeg build.
     """
     stdout = _run([cmd, '-muxers'])
-    return _get_line_fields(stdout, 4, MUXER_RE, MUXER_FLAGS)
+    return _get_line_fields(stdout, 4, MUXER['RE'], MUXER['FLAGS'])
 
 
 def get_codecs(cmd='ffmpeg'):
@@ -140,13 +146,14 @@ def get_codecs(cmd='ffmpeg'):
     Extract the codecs of the ffmpeg build.
     """
     stdout = _run([cmd, '-codecs'])
-    codecs = _get_line_fields(stdout, 10, CODEC_RE, CODEC_FLAGS)
+    codecs = _get_line_fields(stdout, 10, CODEC['RE'], CODEC['FLAGS'])
     for codec in codecs.values():
-        for coders_match in CODEC_CODERS_RE.finditer(codec['description']):
+        for coders_match in CODEC['CODERS_RE'].finditer(codec['description']):
             coders = coders_match.group(3).split()
             if coders:
                 codec[coders_match.group(1)] = coders
-        description_match = CODEC_DESCRIPTION_RE.search(codec['description'])
+        description_match = CODEC['DESCRIPTION_RE'].search(
+            codec['description'])
         if description_match is not None:
             codec['description'] = description_match.group('description')
     return codecs
@@ -179,7 +186,7 @@ def get_filters(cmd='ffmpeg'):
     Extract the filters of the ffmpeg build.
     """
     stdout = _run([cmd, '-filters'])
-    return _get_line_fields(stdout, 8, FILTER_RE, FILTER_FLAGS)
+    return _get_line_fields(stdout, 8, FILTER['RE'], FILTER['FLAGS'])
 
 
 def get_pix_fmts(cmd='ffmpeg'):
@@ -188,7 +195,7 @@ def get_pix_fmts(cmd='ffmpeg'):
     """
     stdout = _run([cmd, '-pix_fmts'])
     return _get_line_fields(
-        stdout, 8, PIX_FMT_RE, PIX_FMT_FLAGS, PIX_FMT_INT_FIELDS)
+        stdout, 8, PIX_FMT['RE'], PIX_FMT['FLAGS'], PIX_FMT['INT_FIELDS'])
 
 
 def get_sample_fmts(cmd='ffmpeg'):
@@ -238,7 +245,7 @@ def get_devices(cmd='ffmpeg'):
     Extract the devices of the ffmpeg build.
     """
     stdout = _run([cmd, '-devices'])
-    return _get_line_fields(stdout, 4, MUXER_RE, MUXER_FLAGS)
+    return _get_line_fields(stdout, 4, MUXER['RE'], MUXER['FLAGS'])
 
 
 def get_hw_devices(cmd='ffmpeg'):
@@ -272,7 +279,7 @@ def get_hwaccels(cmd='ffmpeg'):
                 for coder in codec.get(coders_key, []):
                     for synonym in (
                             [hwaccel_name] +
-                            HWACCEL_SYNONYMS.get(hwaccel_name, [])):
+                            HWACCEL['SYNONYMS'].get(hwaccel_name, [])):
                         if (
                                 coder == synonym or
                                 '_' + synonym in coder or
diff --git a/ffmpeg/_detect.py b/ffmpeg/_detect.py
index e2e8316c..84d048c8 100644
--- a/ffmpeg/_detect.py
+++ b/ffmpeg/_detect.py
@@ -43,23 +43,25 @@
 # Separators to divide a range of models within a line
 MODEL_RANGE_SEPARATORS = ['-', '>']
 
-# List `hwaccel` options by order of expected performance when available.
-HWACCELS_BY_PERFORMANCE = [
-    # NVidia
-    'nvdec', 'cuvid', 'cuda',
-    # AMD
-    'amf',
-    # Windows
-    'qsv', 'd3d11va', 'dxva2',
-    # Linux
-    'vaapi', 'vdpau', 'drm']
-HWACCEL_OUTPUT_FORMATS = {
-    'nvdec': 'cuda',
-    'vaapi': 'vaapi'}
-
-GPU_PRODUCT_RE = re.compile(r'(?P<chip>[^[]+)(\[(?P<board>[^]]+)\]|)')
-GPU_WMI_PROPERTIES = collections.OrderedDict(
-    vendor='AdapterCompatibility', board='VideoProcessor')
+HWACCEL = dict(
+    # List `hwaccel` options by order of expected performance when available.
+    BY_PERFORMANCE=[
+        # NVidia
+        'nvdec', 'cuvid', 'cuda',
+        # AMD
+        'amf',
+        # Windows
+        'qsv', 'd3d11va', 'dxva2',
+        # Linux
+        'vaapi', 'vdpau', 'drm'],
+    OUTPUT_FORMATS={
+        'nvdec': 'cuda',
+        'vaapi': 'vaapi'})
+
+GPU = dict(
+    PRODUCT_RE=re.compile(r'(?P<chip>[^[]+)(\[(?P<board>[^]]+)\]|)'),
+    WMI_PROPERTIES=collections.OrderedDict(
+        vendor='AdapterCompatibility', board='VideoProcessor'))
 
 # Loaded from JSON
 DATA = None
@@ -88,7 +90,7 @@ def detect_gpus():
             # TODO get multiple GPUs from lshw
             gpus.append(gpu)
 
-            product_match = GPU_PRODUCT_RE.search(display_data['product'])
+            product_match = GPU['PRODUCT_RE'].search(display_data['product'])
             if product_match:
                 gpu.update(**product_match.groupdict())
                 if not gpu['board']:
@@ -98,7 +100,7 @@ def detect_gpus():
         import wmi
         for controller in wmi.WMI().Win32_VideoController():
             gpu = collections.OrderedDict()
-            for key, wmi_prop in GPU_WMI_PROPERTIES.items():
+            for key, wmi_prop in GPU['WMI_PROPERTIES'].items():
                 value = controller.wmi_property(wmi_prop).value
                 if value:
                     gpu[key] = value
@@ -192,11 +194,11 @@ def detect_hwaccels(hwaccels=None, cmd='ffmpeg'):
 
     hwaccels.sort(key=lambda hwaccel: (
         # Sort unranked hwaccels last, but in the order given by ffmpeg
-        hwaccel['name'] in HWACCELS_BY_PERFORMANCE and 1 or 0,
+        hwaccel['name'] in HWACCEL['BY_PERFORMANCE'] and 1 or 0,
         (
             # Sort ranked hwaccels per the constant
-            hwaccel['name'] in HWACCELS_BY_PERFORMANCE and
-            HWACCELS_BY_PERFORMANCE.index(hwaccel['name']))))
+            hwaccel['name'] in HWACCEL['BY_PERFORMANCE'] and
+            HWACCEL['BY_PERFORMANCE'].index(hwaccel['name']))))
 
     hwaccels_data['hwaccels'] = hwaccels
     return hwaccels_data
@@ -230,9 +232,9 @@ def detect_codecs(decoder, encoder, hwaccels=None, cmd='ffmpeg'):
                 hwaccel_kwargs = collections.OrderedDict(
                     input=collections.OrderedDict(hwaccel=hwaccel['name']),
                     output=collections.OrderedDict(codec=hwaccel_encoder))
-                if hwaccel['name'] in HWACCEL_OUTPUT_FORMATS:
+                if hwaccel['name'] in HWACCEL['OUTPUT_FORMATS']:
                     hwaccel_kwargs['input']['hwaccel_output_format'] = (
-                        HWACCEL_OUTPUT_FORMATS[hwaccel['name']])
+                        HWACCEL['OUTPUT_FORMATS'][hwaccel['name']])
                 codecs_kwargs.append(hwaccel_kwargs)
                 for hwaccel_decoder in hwaccel['codecs'].get(
                         decoder, {}).get('decoders', []):

From 506d94ab01117545674200847b00d214b6619ae8 Mon Sep 17 00:00:00 2001
From: Ross Patterson <me@rpatterson.net>
Date: Mon, 12 Aug 2019 13:50:36 -0700
Subject: [PATCH 37/37] Detect: Improve hwaccel preference ordering

---
 ffmpeg/_detect.py | 18 +++++++++++-------
 1 file changed, 11 insertions(+), 7 deletions(-)

diff --git a/ffmpeg/_detect.py b/ffmpeg/_detect.py
index 84d048c8..359e98d9 100644
--- a/ffmpeg/_detect.py
+++ b/ffmpeg/_detect.py
@@ -46,14 +46,18 @@
 HWACCEL = dict(
     # List `hwaccel` options by order of expected performance when available.
     BY_PERFORMANCE=[
-        # NVidia
-        'nvdec', 'cuvid', 'cuda',
-        # AMD
+        # NVidia cross-OS
+        'cuda', 'cuvid', 'nvdec',
+        # NVidia Linux
+        'vdpau',
+        # AMD Windows
         'amf',
-        # Windows
-        'qsv', 'd3d11va', 'dxva2',
-        # Linux
-        'vaapi', 'vdpau', 'drm'],
+        # Intel Windows
+        'qsv',
+        # Linux, not GPU specific
+        'vaapi', 'drm',
+        # Windows, not GPU specific
+        'd3d11va', 'dxva2'],
     OUTPUT_FORMATS={
         'nvdec': 'cuda',
         'vaapi': 'vaapi'})