MultiRecordFileReader.h

/*
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#pragma once
 
#ifdef GTEST_BUILD
#include <gtest/gtest.h>
class GTEST_TEST_CLASS_NAME_(MultiRecordFileReaderTest, multiFile);
#endif
 
#include <string>
#include <vector>
 
#include <vrs/IndexRecord.h>
#include <vrs/RecordFileReader.h>
 
namespace vrs {
 
class MultiRecordFileReader {
 public:
  using UniqueStreamId = StreamId;
 
  MultiRecordFileReader();
  MultiRecordFileReader(const MultiRecordFileReader&) = delete;
  MultiRecordFileReader(MultiRecordFileReader&&) = delete;
  virtual ~MultiRecordFileReader();
 
  MultiRecordFileReader& operator=(const MultiRecordFileReader&) = delete;
  MultiRecordFileReader& operator=(MultiRecordFileReader&&) = delete;
 
  int open(const std::vector<std::string>& paths);
 
  int open(const std::vector<FileSpec>& fileSpecs);
 
  int open(const std::string& path) {
    return open(std::vector<std::string>{path});
  }
 
  int open(const FileSpec& fileSpec) {
    return open(std::vector<FileSpec>{fileSpec});
  }
 
  void setRelatedFileTags(std::vector<std::string>&& tags);
 
  int close();
 
  const set<UniqueStreamId>& getStreams() const;
 
  bool isOpened() const {
    return isOpened_;
  }
 
  uint32_t getRecordCount() const;
 
  uint32_t getRecordCount(UniqueStreamId uniqueStreamId) const;
 
  uint32_t getRecordCount(UniqueStreamId uniqueStreamId, Record::Type recordType) const;
 
  const StreamTags& getTags(UniqueStreamId uniqueStreamId) const;
 
  const string& getTag(const string& name) const {
    return getTag(fileTags_, name);
  }
 
  const string& getTag(UniqueStreamId uniqueStreamId, const string& name) const {
    return getTag(getTags(uniqueStreamId).user, name);
  }
 
  vector<std::pair<string, int64_t>> getFileChunks() const;
 
  const string& getFlavor(UniqueStreamId uniqueStreamId) const;
 
  const string& getSerialNumber(UniqueStreamId uniqueStreamId) const;
 
  vector<UniqueStreamId> getStreams(RecordableTypeId typeId, const string& flavor = {}) const;
 
  UniqueStreamId getStreamForName(const string& name) const;
 
  UniqueStreamId getStreamForTag(
      const string& tagName,
      const string& tag,
      RecordableTypeId typeId = RecordableTypeId::Undefined) const;
 
  UniqueStreamId getStreamForSerialNumber(const string& serialNumber) const;
 
  bool mightContainImages(UniqueStreamId uniqueStreamId) const;
 
  bool mightContainAudio(UniqueStreamId uniqueStreamId) const;
 
  uint32_t getRecordIndex(const IndexRecord::RecordInfo* record) const;
 
  const IndexRecord::RecordInfo* getRecord(uint32_t globalIndex) const;
 
  uint32_t getRecordSize(uint32_t globalIndex) const;
 
  const IndexRecord::RecordInfo* getRecord(UniqueStreamId streamId, uint32_t indexNumber) const;
 
  const IndexRecord::RecordInfo*
  getRecord(UniqueStreamId streamId, Record::Type recordType, uint32_t indexNumber) const;
 
  const IndexRecord::RecordInfo* getLastRecord(UniqueStreamId streamId, Record::Type recordType)
      const;
 
  const vector<const IndexRecord::RecordInfo*>& getIndex(UniqueStreamId streamId) const;
 
  const string& getOriginalRecordableTypeName(UniqueStreamId streamId) const {
    return getTag(getTags(streamId).vrs, Recordable::getOriginalNameTagName());
  }
 
  void setStreamPlayer(UniqueStreamId streamId, StreamPlayer* streamPlayer);
 
  uint32_t getRecordFormats(UniqueStreamId streamId, RecordFormatMap& outFormats) const;
 
  int readRecord(const IndexRecord::RecordInfo& recordInfo);
 
  int readRecord(const IndexRecord::RecordInfo& recordInfo, StreamPlayer* player, bool setupPlayer);
 
  bool setCachingStrategy(CachingStrategy cachingStrategy);
 
  CachingStrategy getCachingStrategy() const;
 
  bool prefetchRecordSequence(
      const vector<const IndexRecord::RecordInfo*>& records,
      bool clearSequence = true);
 
  bool isRecordAvailableOrPrefetch(const IndexRecord::RecordInfo& record) const;
 
  bool purgeFileCache();
 
  const map<string, string>& getTags() const {
    return fileTags_;
  }
 
  const IndexRecord::RecordInfo* getFirstRecord(Record::Type recordType) const;
 
  const IndexRecord::RecordInfo* getLastRecord(Record::Type recordType) const;
 
  const IndexRecord::RecordInfo* getRecordByTime(double timestamp) const;
 
  const IndexRecord::RecordInfo* getRecordByTime(UniqueStreamId streamId, double timestamp) const;
 
  const IndexRecord::RecordInfo*
  getRecordByTime(StreamId streamId, Record::Type recordType, double timestamp) const;
 
  const IndexRecord::RecordInfo* getNearestRecordByTime(
      double timestamp,
      double epsilon,
      StreamId streamId = {},
      Record::Type recordType = Record::Type::UNDEFINED) const;
 
  std::unique_ptr<FileHandler> getFileHandler() const;
 
  UniqueStreamId getUniqueStreamId(const IndexRecord::RecordInfo* record) const;
 
  int64_t getTotalSourceSize() const;
 
  bool readFirstConfigurationRecord(
      UniqueStreamId uniqueStreamId,
      StreamPlayer* streamPlayer = nullptr);
 
  bool readFirstConfigurationRecords(StreamPlayer* streamPlayer = nullptr);
 
  bool readFirstConfigurationRecordsForType(
      RecordableTypeId typeId,
      StreamPlayer* streamPlayer = nullptr);
 
  const std::vector<unique_ptr<RecordFileReader>>& getReaders() const {
    return readers_;
  }
 
  static std::unique_ptr<RecordFileReader> reduceToRecordFileReader_TEMPORARY_API_TO_DELETE(
      MultiRecordFileReader& multiRecordFileReader);
 
 private:
  using StreamIdToUniqueIdMap = map<StreamId, UniqueStreamId>;
  using StreamIdReaderPair = std::pair<StreamId, RecordFileReader*>;
 
  bool hasSingleFile() const {
    return readers_.size() == 1;
  }
 
  bool areFilesRelated() const;
 
  void initializeUniqueStreamIds();
 
  void createConsolidatedIndex();
 
  void initializeFileTags();
 
  UniqueStreamId generateUniqueStreamId(StreamId duplicateStreamId) const;
 
  const StreamIdReaderPair* getStreamIdReaderPair(UniqueStreamId uniqueStreamId) const;
 
  static const string& getTag(const map<string, string>& tags, const string& name);
 
  RecordFileReader* getReader(const IndexRecord::RecordInfo* record) const;
 
  UniqueStreamId getUniqueStreamIdInternal(const IndexRecord::RecordInfo* record) const;
  UniqueStreamId getUniqueStreamIdInternal(const RecordFileReader* reader, StreamId streamId) const;
 
  bool timeLessThan(const IndexRecord::RecordInfo* lhs, const IndexRecord::RecordInfo* rhs) const;
 
  class RecordComparatorGT {
   public:
    explicit RecordComparatorGT(const MultiRecordFileReader& parent) : parent_(parent) {}
 
    bool operator()(const IndexRecord::RecordInfo* lhs, const IndexRecord::RecordInfo* rhs) const {
      return parent_.timeLessThan(rhs, lhs);
    }
 
   private:
    const MultiRecordFileReader& parent_;
  };
 
  bool isOpened_{false};
  std::vector<unique_ptr<RecordFileReader>> readers_;
  unique_ptr<std::vector<const IndexRecord::RecordInfo*>> recordIndex_;
  set<UniqueStreamId> uniqueStreamIds_;
  map<const RecordFileReader*, StreamIdToUniqueIdMap> readerStreamIdToUniqueMap_;
  map<UniqueStreamId, StreamIdReaderPair> uniqueToStreamIdReaderPairMap_;
  vector<string> filePaths_;
  const RecordComparatorGT recordComparatorGT_{*this};
  map<string, string> fileTags_;
  vector<string> relatedFileTags_;
 
#ifdef GTEST_BUILD
  FRIEND_TEST(::MultiRecordFileReaderTest, multiFile);
#endif
};
 
} // namespace vrs