framework/replay/backends/gfxreconstruct.py

   1 # coding=utf-8
   2 #
   3 # Copyright (c) 2014, 2016-2017, 2019-2020 Intel Corporation
   4 # Copyright (c) 2019 Collabora Ltd
   5 # Copyright © 2019-2020 Valve Corporation.
   6 #
   7 # Permission is hereby granted, free of charge, to any person obtaining a
   8 # copy of this software and associated documentation files (the "Software"),
   9 # to deal in the Software without restriction, including without limitation
  10 # the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11 # and/or sell copies of the Software, and to permit persons to whom the
  12 # Software is furnished to do so, subject to the following conditions:
  13 #
  14 # The above copyright notice and this permission notice shall be included
  15 # in all copies or substantial portions of the Software.
  16 #
  17 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18 # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20 # THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  21 # OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  22 # ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  23 # OTHER DEALINGS IN THE SOFTWARE.
  24 #
  25 # SPDX-License-Identifier: MIT
  26
  27
  28 """ Module providing a GFXReconstruct dump backend for replayer """
  29
  30 import os
  31 import re
  32 import subprocess
  33 import sys
  34 from os import path
  35
  36 from packaging import version
  37
  38 from framework import core, exceptions
  39
  40 from . import DumpBackendError
  41 from .abstract import DumpBackend, dump_handler
  42 from .register import Registry
  43
  44 __all__ = [
  45     'REGISTRY',
  46     'GFXReconstructBackend',
  47 ]
  48
  49
  50 _MIN_VERSION = version.Version('0.9.4')
  51 _VERSION_RE = re.compile(r'\s*GFXReconstruct Version\s*([0-9]\.[0-9]\.[0-9])')
  52
  53 _TOTAL_FRAMES_RE = re.compile(r'\s*Total frames:\s*([0-9]*)')
  54
  55
  56 class GFXReconstructBackend(DumpBackend):
  57     """ replayer's GFXReconstruct dump backend
  58
  59     This backend uses GFXReconstruct for replaying its traces.
  60
  61     The path to the GFXReconstruct binary is configurable.
  62
  63     It also admits configuration for passing extra parameters to
  64     GFXReconstruct.
  65
  66     """
  67
  68     def __init__(self, trace_path, output_dir=None, calls=None, **kwargs):
  69         super(GFXReconstructBackend, self).__init__(trace_path, output_dir,
  70                                                     calls, **kwargs)
  71         extension = path.splitext(self._trace_path)[1]
  72
  73         if extension != '.gfxr':
  74             raise exceptions.PiglitFatalError(
  75                 'Invalid trace_path: "{}" tried to be dumped '
  76                 'by the GFXReconstructBackend.\n'.format(self._trace_path))
  77
  78     def _get_last_frame_call(self):
  79         gfxrecon_info_bin = core.get_option(
  80             'PIGLIT_REPLAY_GFXRECON_INFO_BINARY',
  81             ('replay', 'gfxrecon-info_bin'),
  82             default='gfxrecon-info')
  83         cmd = [gfxrecon_info_bin, self._trace_path]
  84         ret = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=sys.stderr)
  85         lines = ret.stdout.decode(errors='replace').splitlines()
  86         print(ret.stdout.decode(errors='replace'))
  87         try:
  88             frames = re.search(_TOTAL_FRAMES_RE, lines[2])
  89             return int(frames.group(1))
  90         except Exception:
  91             return -1
  92
  93     def _check_version(self, gfxrecon_replay_bin):
  94         cmd = [gfxrecon_replay_bin, '--version']
  95         ret = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=sys.stderr)
  96         lines = ret.stdout.decode(errors='replace').splitlines()
  97         print(ret.stdout.decode(errors='replace'))
  98         try:
  99             v = re.search(_VERSION_RE, lines[1])
 100             current = version.Version(v.group(1))
 101         except Exception:
 102             raise DumpBackendError(
 103                 '[dump_trace_images] Unable to check the current '
 104                 'gfxrecon-replay version.')
 105         if _MIN_VERSION > current:
 106             raise DumpBackendError(
 107                 '[dump_trace_images] The current gfxrecon-replay version '
 108                 'is {}. Try to update, at least to the {} version.'.format(
 109                     current, _MIN_VERSION))
 110
 111     @dump_handler
 112     def dump(self):
 113         from PIL import Image
 114         outputprefix = path.join(self._output_dir,
 115                                  path.basename(self._trace_path))
 116         gfxrecon_replay_bin = core.get_option(
 117             'PIGLIT_REPLAY_GFXRECON_REPLAY_BINARY',
 118             ('replay', 'gfxrecon-replay_bin'),
 119             default='gfxrecon-replay')
 120         self._check_version(gfxrecon_replay_bin)
 121         if not self._calls:
 122             self._calls = [str(self._get_last_frame_call())]
 123         gfxrecon_replay_extra_args = core.get_option(
 124             'PIGLIT_REPLAY_GFXRECON_REPLAY_EXTRA_ARGS',
 125             ('replay', 'gfxrecon-replay_extra_args'),
 126             default='').split()
 127         cmd = ([gfxrecon_replay_bin] + gfxrecon_replay_extra_args +
 128                ['--screenshots', ','.join(self._calls),
 129                 '--screenshot-dir', self._output_dir,
 130                 self._trace_path])
 131         self._run_logged_command(cmd, None)
 132         for c in self._calls:
 133             bmp = '{}_frame_{}.bmp'.format(path.join(self._output_dir,
 134                                                      'screenshot'),
 135                                            c)
 136             outputfile = '{}-{}.png'.format(outputprefix, c)
 137             print('Writing: {} to {}'.format(bmp, outputfile))
 138             Image.open(bmp).save(outputfile)
 139             os.remove(bmp)
 140
 141
 142 REGISTRY = Registry(
 143     extensions=['.gfxr'],
 144     backend=GFXReconstructBackend,
 145 )