RPProcessInfo.h

/*
 *  Copyright (C) 2017-2018 Team Kodi
 *  This file is part of Kodi - https://kodi.tv
 *
 *  SPDX-License-Identifier: GPL-2.0-or-later
 *  See LICENSES/README.md for more information.
 */

#pragma once

#include "cores/GameSettings.h"
#include "cores/RetroPlayer/RetroPlayerTypes.h"
#include "threads/CriticalSection.h"

#include <functional>
#include <memory>
#include <string>
#include <vector>

#include <libavutil/pixfmt.h>

class CDataCacheCore;

namespace KODI
{
namespace RETRO
{
class CRenderBufferManager;
class CRenderContext;
class CRenderSettings;
class CRPBaseRenderer;
class CRPProcessInfo;
class IRenderBufferPool;

using CreateRPProcessControl = std::function<std::unique_ptr<CRPProcessInfo>()>;

class IRendererFactory
{
public:
  virtual ~IRendererFactory() = default;

  virtual std::string RenderSystemName() const = 0;

  virtual CRPBaseRenderer* CreateRenderer(const CRenderSettings& settings,
                                          CRenderContext& context,
                                          std::shared_ptr<IRenderBufferPool> bufferPool) = 0;

  virtual RenderBufferPoolVector CreateBufferPools(CRenderContext& context) = 0;
};

class CRPProcessInfo
{
public:
  static std::unique_ptr<CRPProcessInfo> CreateInstance();
  static void RegisterProcessControl(const CreateRPProcessControl& createFunc);
  static void RegisterRendererFactory(IRendererFactory* factory);

  virtual ~CRPProcessInfo();

  const std::string& GetPlatformName() const { return m_platformName; }

  std::string GetRenderSystemName(IRenderBufferPool* renderBufferPool) const;

  CRPBaseRenderer* CreateRenderer(IRenderBufferPool* renderBufferPool,
                                  const CRenderSettings& renderSettings);

  void SetDataCache(CDataCacheCore* cache);

  void ResetInfo();


  CRenderContext& GetRenderContext() { return *m_renderContext; }

  CRenderBufferManager& GetBufferManager() { return *m_renderBufferManager; }

  bool HasScalingMethod(SCALINGMETHOD scalingMethod) const;

  SCALINGMETHOD GetDefaultScalingMethod() const { return m_defaultScalingMethod; }


  void SetVideoPixelFormat(AVPixelFormat pixFormat);
  void SetVideoDimensions(int width, int height);
  void SetVideoFps(float fps);

  void SetAudioChannels(const std::string& channels);
  void SetAudioSampleRate(int sampleRate);
  void SetAudioBitsPerSample(int bitsPerSample);

  void SetSpeed(float speed);
  void SetPlayTimes(time_t start, int64_t current, int64_t min, int64_t max);

protected:
  CRPProcessInfo(std::string platformName);

  static std::vector<SCALINGMETHOD> GetScalingMethods();

  // Static factories
  static CreateRPProcessControl m_processControl;
  static std::vector<std::unique_ptr<IRendererFactory>> m_rendererFactories;
  static CCriticalSection m_createSection;

  // Construction parameters
  const std::string m_platformName;

  // Info parameters
  CDataCacheCore* m_dataCache = nullptr;

  // Rendering parameters
  std::unique_ptr<CRenderBufferManager> m_renderBufferManager;

private:
  // Rendering parameters
  std::unique_ptr<CRenderContext> m_renderContext;
  SCALINGMETHOD m_defaultScalingMethod = SCALINGMETHOD::AUTO;
};

} // namespace RETRO
} // namespace KODI