DataCacheCore.h

/*
 *  Copyright (C) 2005-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 "EdlEdit.h"
#include "threads/CriticalSection.h"

#include <atomic>
#include <chrono>
#include <string>
#include <vector>

class CDataCacheCore
{
public:
  CDataCacheCore();
  virtual ~CDataCacheCore();
  static CDataCacheCore& GetInstance();
  void Reset();
  bool HasAVInfoChanges();
  void SignalVideoInfoChange();
  void SignalAudioInfoChange();
  void SignalSubtitleInfoChange();

  // player video info
  void SetVideoDecoderName(std::string name, bool isHw);
  std::string GetVideoDecoderName();
  bool IsVideoHwDecoder();
  void SetVideoDeintMethod(std::string method);
  std::string GetVideoDeintMethod();
  void SetVideoPixelFormat(std::string pixFormat);
  std::string GetVideoPixelFormat();
  void SetVideoStereoMode(std::string mode);
  std::string GetVideoStereoMode();
  void SetVideoDimensions(int width, int height);
  int GetVideoWidth();
  int GetVideoHeight();
  void SetVideoFps(float fps);
  float GetVideoFps();
  void SetVideoDAR(float dar);
  float GetVideoDAR();

  void SetVideoInterlaced(bool isInterlaced);

  bool IsVideoInterlaced();

  // player audio info
  void SetAudioDecoderName(std::string name);
  std::string GetAudioDecoderName();
  void SetAudioChannels(std::string channels);
  std::string GetAudioChannels();
  void SetAudioSampleRate(int sampleRate);
  int GetAudioSampleRate();
  void SetAudioBitsPerSample(int bitsPerSample);
  int GetAudioBitsPerSample();

  // content info

  void SetEditList(const std::vector<EDL::Edit>& editList);

  const std::vector<EDL::Edit>& GetEditList() const;

  void SetCuts(const std::vector<int64_t>& cuts);

  const std::vector<int64_t>& GetCuts() const;

  void SetSceneMarkers(const std::vector<int64_t>& sceneMarkers);

  const std::vector<int64_t>& GetSceneMarkers() const;

  void SetChapters(const std::vector<std::pair<std::string, int64_t>>& chapters);

  const std::vector<std::pair<std::string, int64_t>>& GetChapters() const;

  // render info
  void SetRenderClockSync(bool enabled);
  bool IsRenderClockSync();

  // player states
  void SeekFinished(int64_t offset);

  void SetStateSeeking(bool active);
  bool IsSeeking();

  bool HasPerformedSeek(int64_t lastSecondInterval) const;

  int64_t GetSeekOffSet() const;

  void SetSpeed(float tempo, float speed);
  float GetSpeed();
  float GetTempo();
  void SetFrameAdvance(bool fa);
  bool IsFrameAdvance();
  bool IsPlayerStateChanged();
  void SetGuiRender(bool gui);
  bool GetGuiRender();
  void SetVideoRender(bool video);
  bool GetVideoRender();
  void SetPlayTimes(time_t start, int64_t current, int64_t min, int64_t max);
  void GetPlayTimes(time_t &start, int64_t &current, int64_t &min, int64_t &max);

  time_t GetStartTime();

  int64_t GetPlayTime();

  float GetPlayPercentage();

  int64_t GetMinTime();

  int64_t GetMaxTime();

protected:
  std::atomic_bool m_hasAVInfoChanges = false;

  CCriticalSection m_videoPlayerSection;
  struct SPlayerVideoInfo
  {
    std::string decoderName;
    bool isHwDecoder;
    std::string deintMethod;
    std::string pixFormat;
    std::string stereoMode;
    int width;
    int height;
    float fps;
    float dar;
    bool m_isInterlaced;
  } m_playerVideoInfo;

  CCriticalSection m_audioPlayerSection;
  struct SPlayerAudioInfo
  {
    std::string decoderName;
    std::string channels;
    int sampleRate;
    int bitsPerSample;
  } m_playerAudioInfo;

  mutable CCriticalSection m_contentSection;
  struct SContentInfo
  {
  public:
    void SetEditList(const std::vector<EDL::Edit>& editList) { m_editList = editList; }

    const std::vector<EDL::Edit>& GetEditList() const { return m_editList; }

    void SetCuts(const std::vector<int64_t>& cuts) { m_cuts = cuts; }

    const std::vector<int64_t>& GetCuts() const { return m_cuts; }

    void SetSceneMarkers(const std::vector<int64_t>& sceneMarkers)
    {
      m_sceneMarkers = sceneMarkers;
    }

    const std::vector<int64_t>& GetSceneMarkers() const { return m_sceneMarkers; }

    void SetChapters(const std::vector<std::pair<std::string, int64_t>>& chapters)
    {
      m_chapters = chapters;
    }

    const std::vector<std::pair<std::string, int64_t>>& GetChapters() const { return m_chapters; }

    void Reset()
    {
      m_editList.clear();
      m_chapters.clear();
      m_cuts.clear();
      m_sceneMarkers.clear();
    }

  private:
    std::vector<EDL::Edit> m_editList;
    std::vector<std::pair<std::string, int64_t>> m_chapters;
    std::vector<int64_t> m_cuts;
    std::vector<int64_t> m_sceneMarkers;
  } m_contentInfo;

  CCriticalSection m_renderSection;
  struct SRenderInfo
  {
    bool m_isClockSync;
  } m_renderInfo;

  mutable CCriticalSection m_stateSection;
  bool m_playerStateChanged = false;
  struct SStateInfo
  {
    bool m_stateSeeking{false};
    bool m_renderGuiLayer{false};
    bool m_renderVideoLayer{false};
    float m_tempo{1.0f};
    float m_speed{1.0f};
    bool m_frameAdvance{false};
    std::chrono::time_point<std::chrono::system_clock> m_lastSeekTime{
        std::chrono::time_point<std::chrono::system_clock>{}};
    int64_t m_lastSeekOffset{0};
  } m_stateInfo;

  struct STimeInfo
  {
    time_t m_startTime;
    int64_t m_time;
    int64_t m_timeMax;
    int64_t m_timeMin;
  } m_timeInfo = {};
};