Player.hpp

Go to the documentation of this file.

/*
 * Copyright (C) 2017-2018  Christian Berger
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */

#ifndef CLUON_PLAYER_HPP
#define CLUON_PLAYER_HPP

#include "cluon/cluon.hpp"
#include "cluon/cluonDataStructures.hpp"

#include <cstdint>
#include <deque>
#include <fstream>
#include <functional>
#include <map>
#include <memory>
#include <mutex>
#include <string>
#include <thread>
#include <utility>

namespace cluon {

class LIBCLUON_API IndexEntry {
   public:
    IndexEntry() = default;
    IndexEntry(const int64_t &sampleTimeStamp, const uint64_t &filePosition) noexcept;

   public:
    int64_t m_sampleTimeStamp{0};
    uint64_t m_filePosition{0};
    bool m_available{0};
};

class LIBCLUON_API Player {
   private:
    enum {
        ONE_MILLISECOND_IN_MICROSECONDS = 1000,
        ONE_SECOND_IN_MICROSECONDS      = 1000 * ONE_MILLISECOND_IN_MICROSECONDS,
        MAX_DELAY_IN_MICROSECONDS       = 1 * ONE_SECOND_IN_MICROSECONDS,
        LOOK_AHEAD_IN_S                 = 30,
        MIN_ENTRIES_FOR_LOOK_AHEAD      = 5000,
    };

   private:
    Player(const Player &) = delete;
    Player(Player &&)      = delete;
    Player &operator=(Player &&) = delete;
    Player &operator=(const Player &other) = delete;

   public:
    Player(const std::string &file, const bool &autoRewind, const bool &threading) noexcept;
    ~Player();

    std::pair<bool, cluon::data::Envelope> getNextEnvelopeToBeReplayed() noexcept;

    uint32_t delay() const noexcept;

    bool hasMoreData() const noexcept;

    void rewind() noexcept;

    void seekTo(float ratio) noexcept;

    uint32_t totalNumberOfEnvelopesInRecFile() const noexcept;

   private:
    // Internal methods without Lock.
    bool hasMoreDataFromRecFile() const noexcept;

    void initializeIndex() noexcept;

    void computeInitialCacheLevelAndFillCache() noexcept;

    void resetCaches() noexcept;

    inline void resetIterators() noexcept;

    uint32_t fillEnvelopeCache(const uint32_t &maxNumberOfEntriesToReadFromFile) noexcept;

    inline void checkAvailabilityOfNextEnvelopeToBeReplayed() noexcept;

   private: // Data for the Player.
    bool m_threading;

    std::string m_file;

    // Handle to .rec file.
    std::fstream m_recFile;
    bool m_recFileValid;

   private: // Player states.
    bool m_autoRewind;

   private: // Index and cache management.
    // Global index: Mapping SampleTimeStamp --> cache entry (holding the actual content from .rec file).
    mutable std::mutex m_indexMutex;
    std::multimap<int64_t, IndexEntry> m_index;

    // Pointers to the current envelope to be replayed and the
    // envelope that has be replayed from the global index.
    std::multimap<int64_t, IndexEntry>::iterator m_previousPreviousEnvelopeAlreadyReplayed;
    std::multimap<int64_t, IndexEntry>::iterator m_previousEnvelopeAlreadyReplayed;
    std::multimap<int64_t, IndexEntry>::iterator m_currentEnvelopeToReplay;

    // Information about the index.
    std::multimap<int64_t, IndexEntry>::iterator m_nextEntryToReadFromRecFile;

    uint32_t m_desiredInitialLevel;

    // Fields to compute replay throughput for cache management.
    cluon::data::TimeStamp m_firstTimePointReturningAEnvelope;
    uint64_t m_numberOfReturnedEnvelopesInTotal;

    uint32_t m_delay;

   private:
    void setEnvelopeCacheFillingRunning(const bool &running) noexcept;
    bool isEnvelopeCacheFillingRunning() const noexcept;

    void manageCache() noexcept;

    float checkRefillingCache(const uint32_t &numberOfEntries, float refillMultiplicator) noexcept;

   private:
    mutable std::mutex m_envelopeCacheFillingThreadIsRunningMutex;
    bool m_envelopeCacheFillingThreadIsRunning;
    std::thread m_envelopeCacheFillingThread;

    // Mapping of pos_type (within .rec file) --> cluon::data::Envelope (read from .rec file).
    std::map<uint64_t, cluon::data::Envelope> m_envelopeCache;

   public:
    void setPlayerListener(std::function<void(cluon::data::PlayerStatus playerStatus)> playerListener) noexcept;

   private:
    std::mutex m_playerListenerMutex;
    std::function<void(cluon::data::PlayerStatus playerStatus)> m_playerListener{nullptr};
};

} // namespace cluon

#endif