driver.cpp

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
 */
 
#include "stdafx.h"
#include "debug.h"
#include "error.h"
#include "sound/sound_driver.hpp"
#include "music/music_driver.hpp"
#include "video/video_driver.hpp"
#include "string_func.h"
#include "table/strings.h"
#include "fileio_func.h"
#include <string>
#include <sstream>
 
#ifdef _WIN32
# include <windows.h>
#else
# include <unistd.h>
#endif /* _WIN32 */
 
#include "safeguards.h"
 
std::string _ini_videodriver;        
std::vector<Dimension> _resolutions; 
Dimension _cur_resolution;           
bool _rightclick_emulate;            
 
std::string _ini_sounddriver;        
 
std::string _ini_musicdriver;        
 
std::string _ini_blitter;            
bool _blitter_autodetected;          
 
static const std::string HWACCELERATION_TEST_FILE = "hwaccel.dat"; 
 
const char *GetDriverParam(const StringList &parm, const char *name)
{
  if (parm.empty()) return nullptr;
 
  size_t len = strlen(name);
  for (auto &p : parm) {
    if (p.compare(0, len, name) == 0) {
      if (p.length() == len) return "";
      if (p[len] == '=') return p.c_str() + len + 1;
    }
  }
  return nullptr;
}
 
bool GetDriverParamBool(const StringList &parm, const char *name)
{
  return GetDriverParam(parm, name) != nullptr;
}
 
int GetDriverParamInt(const StringList &parm, const char *name, int def)
{
  const char *p = GetDriverParam(parm, name);
  return p != nullptr ? atoi(p) : def;
}
 
void DriverFactoryBase::SelectDriver(const std::string &name, Driver::Type type)
{
  if (!DriverFactoryBase::SelectDriverImpl(name, type)) {
    name.empty() ?
      usererror("Failed to autoprobe %s driver", GetDriverTypeName(type)) :
      usererror("Failed to select requested %s driver '%s'", GetDriverTypeName(type), name.c_str());
  }
}
 
bool DriverFactoryBase::SelectDriverImpl(const std::string &name, Driver::Type type)
{
  if (GetDrivers().size() == 0) return false;
 
  if (name.empty()) {
    /* Probe for this driver, but do not fall back to dedicated/null! */
    for (int priority = 10; priority > 0; priority--) {
      Drivers::iterator it = GetDrivers().begin();
      for (; it != GetDrivers().end(); ++it) {
        DriverFactoryBase *d = (*it).second;
 
        /* Check driver type */
        if (d->type != type) continue;
        if (d->priority != priority) continue;
 
        if (type == Driver::DT_VIDEO && !_video_hw_accel && d->UsesHardwareAcceleration()) continue;
 
        if (type == Driver::DT_VIDEO && _video_hw_accel && d->UsesHardwareAcceleration()) {
          /* Check if we have already tried this driver in last run.
           * If it is here, it most likely means we crashed. So skip
           * hardware acceleration. */
          auto filename = FioFindFullPath(BASE_DIR, HWACCELERATION_TEST_FILE.c_str());
          if (!filename.empty()) {
            unlink(filename.c_str());
 
            Debug(driver, 1, "Probing {} driver '{}' skipped due to earlier crash", GetDriverTypeName(type), d->name);
 
            _video_hw_accel = false;
            ErrorMessageData msg(STR_VIDEO_DRIVER_ERROR, STR_VIDEO_DRIVER_ERROR_HARDWARE_ACCELERATION_CRASH, true);
            ScheduleErrorMessage(msg);
            continue;
          }
 
          /* Write empty file to note we are attempting hardware acceleration. */
          auto f = FioFOpenFile(HWACCELERATION_TEST_FILE.c_str(), "w", BASE_DIR);
          FioFCloseFile(f);
        }
 
        Driver *oldd = *GetActiveDriver(type);
        Driver *newd = d->CreateInstance();
        *GetActiveDriver(type) = newd;
 
        const char *err = newd->Start({});
        if (err == nullptr) {
          Debug(driver, 1, "Successfully probed {} driver '{}'", GetDriverTypeName(type), d->name);
          delete oldd;
          return true;
        }
 
        *GetActiveDriver(type) = oldd;
        Debug(driver, 1, "Probing {} driver '{}' failed with error: {}", GetDriverTypeName(type), d->name, err);
        delete newd;
 
        if (type == Driver::DT_VIDEO && _video_hw_accel && d->UsesHardwareAcceleration()) {
          _video_hw_accel = false;
          ErrorMessageData msg(STR_VIDEO_DRIVER_ERROR, STR_VIDEO_DRIVER_ERROR_NO_HARDWARE_ACCELERATION, true);
          ScheduleErrorMessage(msg);
        }
      }
    }
    usererror("Couldn't find any suitable %s driver", GetDriverTypeName(type));
  } else {
    /* Extract the driver name and put parameter list in parm */
    std::istringstream buffer(name);
    std::string dname;
    std::getline(buffer, dname, ':');
 
    std::string param;
    std::vector<std::string> parms;
    while (std::getline(buffer, param, ',')) {
      parms.push_back(param);
    }
 
    /* Find this driver */
    Drivers::iterator it = GetDrivers().begin();
    for (; it != GetDrivers().end(); ++it) {
      DriverFactoryBase *d = (*it).second;
 
      /* Check driver type */
      if (d->type != type) continue;
 
      /* Check driver name */
      if (strcasecmp(dname.c_str(), d->name) != 0) continue;
 
      /* Found our driver, let's try it */
      Driver *newd = d->CreateInstance();
 
      const char *err = newd->Start(parms);
      if (err != nullptr) {
        delete newd;
        usererror("Unable to load driver '%s'. The error was: %s", d->name, err);
      }
 
      Debug(driver, 1, "Successfully loaded {} driver '{}'", GetDriverTypeName(type), d->name);
      delete *GetActiveDriver(type);
      *GetActiveDriver(type) = newd;
      return true;
    }
    usererror("No such %s driver: %s\n", GetDriverTypeName(type), dname.c_str());
  }
}
 
void DriverFactoryBase::MarkVideoDriverOperational()
{
  /* As part of the detection whether the GPU driver crashes the game,
   * and as we are operational now, remove the hardware acceleration
   * test-file. */
  auto filename = FioFindFullPath(BASE_DIR, HWACCELERATION_TEST_FILE.c_str());
  if (!filename.empty()) unlink(filename.c_str());
}
 
char *DriverFactoryBase::GetDriversInfo(char *p, const char *last)
{
  for (Driver::Type type = Driver::DT_BEGIN; type != Driver::DT_END; type++) {
    p += seprintf(p, last, "List of %s drivers:\n", GetDriverTypeName(type));
 
    for (int priority = 10; priority >= 0; priority--) {
      Drivers::iterator it = GetDrivers().begin();
      for (; it != GetDrivers().end(); it++) {
        DriverFactoryBase *d = (*it).second;
        if (d->type != type) continue;
        if (d->priority != priority) continue;
        p += seprintf(p, last, "%18s: %s\n", d->name, d->GetDescription());
      }
    }
 
    p += seprintf(p, last, "\n");
  }
 
  return p;
}
 
DriverFactoryBase::DriverFactoryBase(Driver::Type type, int priority, const char *name, const char *description) :
  type(type), priority(priority), name(name), description(description)
{
  /* Prefix the name with driver type to make it unique */
  char buf[32];
  strecpy(buf, GetDriverTypeName(type), lastof(buf));
  strecpy(buf + 5, name, lastof(buf));
 
  Drivers &drivers = GetDrivers();
  assert(drivers.find(buf) == drivers.end());
  drivers.insert(Drivers::value_type(buf, this));
}
 
DriverFactoryBase::~DriverFactoryBase()
{
  /* Prefix the name with driver type to make it unique */
  char buf[32];
  strecpy(buf, GetDriverTypeName(type), lastof(buf));
  strecpy(buf + 5, this->name, lastof(buf));
 
  Drivers::iterator it = GetDrivers().find(buf);
  assert(it != GetDrivers().end());
 
  GetDrivers().erase(it);
  if (GetDrivers().empty()) delete &GetDrivers();
}