code: def get_extensions():
      this_dir = os.path.dirname(os.path.abspath(__file__))
      extensions_dir = os.path.join(this_dir, "torchvision", "csrc")
  
      main_file = (
          glob.glob(os.path.join(extensions_dir, "*.cpp"))
          + glob.glob(os.path.join(extensions_dir, "ops", "*.cpp"))
          + glob.glob(
              os.path.join(extensions_dir, "ops", "autocast", "*.cpp")
          )
      )
      source_cpu = (
          glob.glob(
              os.path.join(extensions_dir, "ops", "autograd", "*.cpp")
          )
          + glob.glob(
              os.path.join(extensions_dir, "ops", "cpu", "*.cpp")
          )
          + glob.glob(
              os.path.join(
                  extensions_dir, "ops", "quantized", "cpu", "*.cpp"
              )
          )
      )
      source_mps = glob.glob(
          os.path.join(extensions_dir, "ops", "mps", "*.mm")
      )
  
      print("Compiling extensions with following flags:")
      force_cuda = os.getenv("FORCE_CUDA", "0") == "1"
      print(f"  FORCE_CUDA: {force_cuda}")
      force_mps = os.getenv("FORCE_MPS", "0") == "1"
      print(f"  FORCE_MPS: {force_mps}")
      debug_mode = os.getenv("DEBUG", "0") == "1"
      print(f"  DEBUG: {debug_mode}")
      use_png = os.getenv("TORCHVISION_USE_PNG", "1") == "1"
      print(f"  TORCHVISION_USE_PNG: {use_png}")
      use_jpeg = os.getenv("TORCHVISION_USE_JPEG", "1") == "1"
      print(f"  TORCHVISION_USE_JPEG: {use_jpeg}")
      use_nvjpeg = os.getenv("TORCHVISION_USE_NVJPEG", "1") == "1"
      print(f"  TORCHVISION_USE_NVJPEG: {use_nvjpeg}")
      use_ffmpeg = os.getenv("TORCHVISION_USE_FFMPEG", "1") == "1"
      print(f"  TORCHVISION_USE_FFMPEG: {use_ffmpeg}")
      use_video_codec = (
          os.getenv("TORCHVISION_USE_VIDEO_CODEC", "1") == "1"
      )
      print(f"  TORCHVISION_USE_VIDEO_CODEC: {use_video_codec}")
  
      nvcc_flags = os.getenv("NVCC_FLAGS", "")
      print(f"  NVCC_FLAGS: {nvcc_flags}")
  
      is_rocm_pytorch = False
  
      if torch.__version__ >= "1.5":
          from torch.utils.cpp_extension import ROCM_HOME
  
          is_rocm_pytorch = (torch.version.hip is not None) and (
              ROCM_HOME is not None
          )
  
      if is_rocm_pytorch:
          from torch.utils.hipify import hipify_python
  
          hipify_python.hipify(
              project_directory=this_dir,
              output_directory=this_dir,
              includes="torchvision/csrc/ops/cuda/*",
              show_detailed=True,
              is_pytorch_extension=True,
          )
          source_cuda = glob.glob(
              os.path.join(extensions_dir, "ops", "hip", "*.hip")
          )
          # Copy over additional files
          for file in glob.glob(r"torchvision/csrc/ops/cuda/*.h"):
              shutil.copy(file, "torchvision/csrc/ops/hip")
      else:
          source_cuda = glob.glob(
              os.path.join(extensions_dir, "ops", "cuda", "*.cu")
          )
  
      sources = main_file + source_cpu
      extension = CppExtension
  
      define_macros = []
  
      extra_compile_args = {"cxx": []}
      if (
          torch.cuda.is_available()
          and ((CUDA_HOME is not None) or is_rocm_pytorch)
      ) or force_cuda:
          extension = CUDAExtension
          sources += source_cuda
          if not is_rocm_pytorch:
              define_macros += [("WITH_CUDA", None)]
              if nvcc_flags == "":
                  nvcc_flags = []
              else:
                  nvcc_flags = nvcc_flags.split(" ")
          else:
              define_macros += [("WITH_HIP", None)]
              nvcc_flags = []
          extra_compile_args["nvcc"] = nvcc_flags
      elif torch.backends.mps.is_available() or force_mps:
          sources += source_mps
  
      if sys.platform == "win32":
          define_macros += [("torchvision_EXPORTS", None)]
          define_macros += [("USE_PYTHON", None)]
          extra_compile_args["cxx"].append("/MP")
  
      if debug_mode:
          print("Compiling in debug mode")
          extra_compile_args["cxx"].append("-g")
          extra_compile_args["cxx"].append("-O0")
          if "nvcc" in extra_compile_args:
              # we have to remove "-OX" and "-g" flag if exists and append
              nvcc_flags = extra_compile_args["nvcc"]
              extra_compile_args["nvcc"] = [
                  f for f in nvcc_flags if not ("-O" in f or "-g" in f)
              ]
              extra_compile_args["nvcc"].append("-O0")
              extra_compile_args["nvcc"].append("-g")
      else:
          print("Compiling with debug mode OFF")
          extra_compile_args["cxx"].append("-g0")
  
      sources = [os.path.join(extensions_dir, s) for s in sources]
  
      include_dirs = [extensions_dir]
  
      ext_modules = [
          extension(
              "torchvision._C",
              sorted(sources),
              include_dirs=include_dirs,
              define_macros=define_macros,
              extra_compile_args=extra_compile_args,
          )
      ]
  
      # ------------------- Torchvision extra extensions ------------------------
      vision_include = os.environ.get("TORCHVISION_INCLUDE", None)
      vision_library = os.environ.get("TORCHVISION_LIBRARY", None)
      vision_include = (
          vision_include.split(os.pathsep)
          if vision_include is not None
          else []
      )
      vision_library = (
          vision_library.split(os.pathsep)
          if vision_library is not None
          else []
      )
      include_dirs += vision_include
      library_dirs = vision_library
  
      # Image reading extension
      image_macros = []
      image_include = [extensions_dir]
      image_library = []
      image_link_flags = []
  
      if sys.platform == "win32":
          image_macros += [("USE_PYTHON", None)]
  
      # Locating libPNG
      libpng = shutil.which("libpng-config")
      pngfix = shutil.which("pngfix")
      png_found = libpng is not None or pngfix is not None
  
      use_png = use_png and png_found
      if use_png:
          print("Found PNG library")
          if libpng is not None:
              # Linux / Mac
              min_version = "1.6.0"
              png_version = subprocess.run(
                  [libpng, "--version"], stdout=subprocess.PIPE
              )
              png_version = png_version.stdout.strip().decode("utf-8")
              png_version = parse_version(png_version)
              if png_version >= parse_version(min_version):
                  print("Building torchvision with PNG image support")
                  png_lib = subprocess.run(
                      [libpng, "--libdir"], stdout=subprocess.PIPE
                  )
                  png_lib = png_lib.stdout.strip().decode("utf-8")
                  if "disabled" not in png_lib:
                      image_library += [png_lib]
                  png_include = subprocess.run(
                      [libpng, "--I_opts"], stdout=subprocess.PIPE
                  )
                  png_include = png_include.stdout.strip().decode(
                      "utf-8"
                  )
                  _, png_include = png_include.split("-I")
                  image_include += [png_include]
                  image_link_flags.append("png")
                  print(f"  libpng version: {png_version}")
                  print(f"  libpng include path: {png_include}")
              else:
                  print(
                      "Could not add PNG image support to torchvision:"
                  )
                  print(
                      f"  libpng minimum version {min_version}, found {png_version}"
                  )
                  use_png = False
          else:
              # Windows
              png_lib = os.path.join(
                  os.path.dirname(os.path.dirname(pngfix)), "lib"
              )
              png_include = os.path.join(
                  os.path.dirname(os.path.dirname(pngfix)),
                  "include",
                  "libpng16",
              )
              image_library += [png_lib]
              image_include += [png_include]
              image_link_flags.append("libpng")
      else:
          print("Building torchvision without PNG image support")
      image_macros += [("PNG_FOUND", str(int(use_png)))]
  
      # Locating libjpeg
      (jpeg_found, jpeg_conda, jpeg_include, jpeg_lib) = find_library(
          "jpeglib", vision_include
      )
  
      use_jpeg = use_jpeg and jpeg_found
      if use_jpeg:
          print("Building torchvision with JPEG image support")
          print(f"  libjpeg include path: {jpeg_include}")
          print(f"  libjpeg lib path: {jpeg_lib}")
          image_link_flags.append("jpeg")
          if jpeg_conda:
              image_library += [jpeg_lib]
              image_include += [jpeg_include]
      else:
          print("Building torchvision without JPEG image support")
      image_macros += [("JPEG_FOUND", str(int(use_jpeg)))]
  
      # Locating nvjpeg
      # Should be included in CUDA_HOME for CUDA >= 10.1, which is the minimum version we have in the CI
      nvjpeg_found = (
          extension is CUDAExtension
          and CUDA_HOME is not None
          and os.path.exists(
              os.path.join(CUDA_HOME, "include", "nvjpeg.h")
          )
      )
  
      use_nvjpeg = use_nvjpeg and nvjpeg_found
      if use_nvjpeg:
          print("Building torchvision with NVJPEG image support")
          image_link_flags.append("nvjpeg")
      else:
          print("Building torchvision without NVJPEG image support")
      image_macros += [("NVJPEG_FOUND", str(int(use_nvjpeg)))]
  
      image_path = os.path.join(extensions_dir, "io", "image")
      image_src = glob.glob(
          os.path.join(image_path, "*.cpp")
      ) + glob.glob(os.path.join(image_path, "cpu", "*.cpp"))
  
      if is_rocm_pytorch:
          image_src += glob.glob(
              os.path.join(image_path, "hip", "*.cpp")
          )
          # we need to exclude this in favor of the hipified source
          image_src.remove(os.path.join(image_path, "image.cpp"))
      else:
          image_src += glob.glob(
              os.path.join(image_path, "cuda", "*.cpp")
          )
  
      if use_png or use_jpeg:
          ext_modules.append(
              extension(
                  "torchvision.image",
                  image_src,
                  include_dirs=image_include
                  + include_dirs
                  + [image_path],
                  library_dirs=image_library + library_dirs,
                  define_macros=image_macros,
                  libraries=image_link_flags,
                  extra_compile_args=extra_compile_args,
              )
          )
  
      # Locating ffmpeg
      ffmpeg_exe = shutil.which("ffmpeg")
      has_ffmpeg = ffmpeg_exe is not None
      ffmpeg_version = None
      # FIXME: Building torchvision with ffmpeg on MacOS or with Python 3.9
      # FIXME: causes crash. See the following GitHub issues for more details.
      # FIXME: https://github.com/pytorch/pytorch/issues/65000
      # FIXME: https://github.com/pytorch/vision/issues/3367
      if sys.platform != "linux" or (
          sys.version_info.major == 3 and sys.version_info.minor == 9
      ):
          has_ffmpeg = False
      if has_ffmpeg:
          try:
              # This is to check if ffmpeg is installed properly.
              ffmpeg_version = subprocess.check_output(
                  ["ffmpeg", "-version"]
              )
          except subprocess.CalledProcessError:
              print("Building torchvision without ffmpeg support")
              print("  Error fetching ffmpeg version, ignoring ffmpeg.")
              has_ffmpeg = False
  
      use_ffmpeg = use_ffmpeg and has_ffmpeg
  
      if use_ffmpeg:
          ffmpeg_libraries = {
              "libavcodec",
              "libavformat",
              "libavutil",
              "libswresample",
              "libswscale",
          }
  
          ffmpeg_bin = os.path.dirname(ffmpeg_exe)
          ffmpeg_root = os.path.dirname(ffmpeg_bin)
          ffmpeg_include_dir = os.path.join(ffmpeg_root, "include")
          ffmpeg_library_dir = os.path.join(ffmpeg_root, "lib")
  
          gcc = os.environ.get("CC", shutil.which("gcc"))
          platform_tag = subprocess.run(
              [gcc, "-print-multiarch"], stdout=subprocess.PIPE
          )
          platform_tag = platform_tag.stdout.strip().decode("utf-8")
  
          if platform_tag:
              # Most probably a Debian-based distribution
              ffmpeg_include_dir = [
                  ffmpeg_include_dir,
                  os.path.join(ffmpeg_include_dir, platform_tag),
              ]
              ffmpeg_library_dir = [
                  ffmpeg_library_dir,
                  os.path.join(ffmpeg_library_dir, platform_tag),
              ]
          else:
              ffmpeg_include_dir = [ffmpeg_include_dir]
              ffmpeg_library_dir = [ffmpeg_library_dir]
  
          for library in ffmpeg_libraries:
              library_found = False
              for search_path in ffmpeg_include_dir + include_dirs:
                  full_path = os.path.join(search_path, library, "*.h")
                  library_found |= len(glob.glob(full_path)) > 0
  
              if not library_found:
                  print("Building torchvision without ffmpeg support")
                  print(
                      f"  {library} header files were not found, disabling ffmpeg support"
                  )
                  use_ffmpeg = False
      else:
          print("Building torchvision without ffmpeg support")
  
      if use_ffmpeg:
          print("Building torchvision with ffmpeg support")
          print(f"  ffmpeg version: {ffmpeg_version}")
          print(f"  ffmpeg include path: {ffmpeg_include_dir}")
          print(f"  ffmpeg library_dir: {ffmpeg_library_dir}")
  
          # TorchVision base decoder + video reader
          video_reader_src_dir = os.path.join(
              this_dir, "torchvision", "csrc", "io", "video_reader"
          )
          video_reader_src = glob.glob(
              os.path.join(video_reader_src_dir, "*.cpp")
          )
          base_decoder_src_dir = os.path.join(
              this_dir, "torchvision", "csrc", "io", "decoder"
          )
          base_decoder_src = glob.glob(
              os.path.join(base_decoder_src_dir, "*.cpp")
          )
          # Torchvision video API
          videoapi_src_dir = os.path.join(
              this_dir, "torchvision", "csrc", "io", "video"
          )
          videoapi_src = glob.glob(
              os.path.join(videoapi_src_dir, "*.cpp")
          )
          # exclude tests
          base_decoder_src = [
              x for x in base_decoder_src if "_test.cpp" not in x
          ]
  
          combined_src = (
              video_reader_src + base_decoder_src + videoapi_src
          )
  
          ext_modules.append(
              CppExtension(
                  "torchvision.video_reader",
                  combined_src,
                  include_dirs=[
                      base_decoder_src_dir,
                      video_reader_src_dir,
                      videoapi_src_dir,
                      extensions_dir,
                      *ffmpeg_include_dir,
                      *include_dirs,
                  ],
                  library_dirs=ffmpeg_library_dir + library_dirs,
                  libraries=[
                      "avcodec",
                      "avformat",
                      "avutil",
                      "swresample",
                      "swscale",
                  ],
                  extra_compile_args=["-std=c++17"]
                  if os.name != "nt"
                  else ["/std:c++17", "/MP"],
                  extra_link_args=[
                      "-std=c++17" if os.name != "nt" else "/std:c++17"
                  ],
              )
          )
  
      # Locating video codec
      # CUDA_HOME should be set to the cuda root directory.
      # TORCHVISION_INCLUDE and TORCHVISION_LIBRARY should include the location to
      # video codec header files and libraries respectively.
      video_codec_found = (
          extension is CUDAExtension
          and CUDA_HOME is not None
          and any(
              [
                  os.path.exists(os.path.join(folder, "cuviddec.h"))
                  for folder in vision_include
              ]
          )
          and any(
              [
                  os.path.exists(os.path.join(folder, "nvcuvid.h"))
                  for folder in vision_include
              ]
          )
          and any(
              [
                  os.path.exists(os.path.join(folder, "libnvcuvid.so"))
                  for folder in library_dirs
              ]
          )
      )
  
      use_video_codec = use_video_codec and video_codec_found
      if (
          use_video_codec
          and use_ffmpeg
          and any(
              [
                  os.path.exists(
                      os.path.join(folder, "libavcodec", "bsf.h")
                  )
                  for folder in ffmpeg_include_dir
              ]
          )
      ):
          print("Building torchvision with video codec support")
          gpu_decoder_path = os.path.join(
              extensions_dir, "io", "decoder", "gpu"
          )
          gpu_decoder_src = glob.glob(
              os.path.join(gpu_decoder_path, "*.cpp")
          )
          cuda_libs = os.path.join(CUDA_HOME, "lib64")
          cuda_inc = os.path.join(CUDA_HOME, "include")
  
          ext_modules.append(
              extension(
                  "torchvision.Decoder",
                  gpu_decoder_src,
                  include_dirs=include_dirs
                  + [gpu_decoder_path]
                  + [cuda_inc]
                  + ffmpeg_include_dir,
                  library_dirs=ffmpeg_library_dir
                  + library_dirs
                  + [cuda_libs],
                  libraries=[
                      "avcodec",
                      "avformat",
                      "avutil",
                      "swresample",
                      "swscale",
                      "nvcuvid",
                      "cuda",
                      "cudart",
                      "z",
                      "pthread",
                      "dl",
                      "nppicc",
                  ],
                  extra_compile_args=extra_compile_args,
              )
          )
      else:
          print("Building torchvision without video codec support")
          if (
              use_video_codec
              and use_ffmpeg
              and not any(
                  [
                      os.path.exists(
                          os.path.join(folder, "libavcodec", "bsf.h")
                      )
                      for folder in ffmpeg_include_dir
                  ]
              )
          ):
              print(
                  "  The installed version of ffmpeg is missing the header file 'bsf.h' which is "
                  "  required for GPU video decoding. Please install the latest ffmpeg from conda-forge channel:"
                  "   `conda install -c conda-forge ffmpeg`."
              )
  
      return ext_modules
  
file_path: vision/setup.py
imports: import distutils.command.clean
  import distutils.spawn
  import glob
  import os
  import shutil
  import subprocess
  import sys
  import torch
  from pkg_resources import DistributionNotFound, get_distribution, parse_version
  from setuptools import find_packages, setup
  from torch.utils.cpp_extension import BuildExtension, CppExtension, CUDA_HOME, CUDAExtension
label_desc: Use image node_id 5 for calling a global function with example usage: get_extensions() and returns: ext_modules