RecordFormatStreamPlayer.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
 
#include <limits>
#include <map>
#include <tuple>
 
#include <vrs/ContentBlockReader.h>
#include <vrs/DataLayout.h>
#include <vrs/RecordFormat.h>
#include <vrs/StreamPlayer.h>
#include <vrs/VrsExport.h>
#include <vrs/os/UndoWindows.h>
 
namespace vrs {
 
using std::map;
using std::pair;
using std::string;
using std::tuple;
using std::unique_ptr;
using std::vector;
 
class DataLayoutBlockReader;
class ImageBlockReader;
class AudioBlockReader;
 
namespace datalayout_conventions {
class VideoFrameSpec;
}
 
struct RecordFormatReader {
  double lastReadRecordTimestamp = std::numeric_limits<double>::max();
  RecordFormat recordFormat;
  vector<unique_ptr<ContentBlockReader>> contentReaders;
  vector<unique_ptr<DataLayout>> expectedDataLayouts;
  vector<unique_ptr<DataLayout>> legacyDataLayouts;
};
 
class VRS_API RecordFormatStreamPlayer : public StreamPlayer {
 public:
  RecordFormatStreamPlayer() = default;
  // Move-only: holds maps of move-only RecordFormatReader. The copy operations are deleted (and
  // declared explicitly so MSVC does not try to emit the deleted implicit copy when the class is
  // dllexport'd — C2280); the move operations stay defaulted so the implicit move is not
  // suppressed.
  RecordFormatStreamPlayer(const RecordFormatStreamPlayer&) = delete;
  RecordFormatStreamPlayer& operator=(const RecordFormatStreamPlayer&) = delete;
  RecordFormatStreamPlayer(RecordFormatStreamPlayer&&) = default;
  RecordFormatStreamPlayer& operator=(RecordFormatStreamPlayer&&) = default;
  ~RecordFormatStreamPlayer() override = default;
  virtual bool
  onDataLayoutRead(const CurrentRecord& /* record */, size_t /* blockIndex */, DataLayout&) {
    return true; // we can go read the next block, if any, since we've read the data
  }
 
  virtual bool onImageRead(const CurrentRecord& record, size_t blockIndex, const ContentBlock& cb) {
    return onUnsupportedBlock(record, blockIndex, cb);
  }
 
  virtual bool onAudioRead(const CurrentRecord& record, size_t blockIndex, const ContentBlock& cb) {
    return onUnsupportedBlock(record, blockIndex, cb);
  }
 
  virtual bool onCustomBlockRead(const CurrentRecord& rec, size_t blkIdx, const ContentBlock& cb) {
    return onUnsupportedBlock(rec, blkIdx, cb);
  }
 
  virtual bool onUnsupportedBlock(const CurrentRecord& rec, size_t blkIdx, const ContentBlock& cb);
 
  void onAttachedToFileReader(RecordFileReader& recordFileReader, StreamId streamId) override;
 
  bool processRecordHeader(const CurrentRecord& record, DataReference& outDataReference) override;
  void processRecord(const CurrentRecord& record, uint32_t readSize) override;
 
  RecordFormatReader* getLastRecordFormatReader(StreamId id, Record::Type recordType) const;
 
  RecordFormatReader* getCurrentRecordFormatReader() const {
    return currentReader_;
  }
 
 protected:
  // Helper class, to be used exclusively during onXXXRead() callbacks,
  // to get the wished for DataLayout
  template <class T>
  inline T& getExpectedLayout(DataLayout& layout, size_t blockIndex) {
    return getCachedLayout<T>(currentReader_->expectedDataLayouts, layout, blockIndex);
  }
  // Helper class, to be used exclusively during onXXXRead() callbacks,
  // to get legacy fields no longer present in the official layout, for backward compatibility needs
  template <class T>
  inline T& getLegacyLayout(DataLayout& layout, size_t blockIndex) {
    return getCachedLayout<T>(currentReader_->legacyDataLayouts, layout, blockIndex);
  }
  template <class T>
  T& getCachedLayout(
      vector<unique_ptr<DataLayout>>& layoutCache,
      DataLayout& layout,
      size_t blockIndex) {
    if (layoutCache.size() <= blockIndex) {
      layoutCache.resize(blockIndex + 1);
    }
    if (!layoutCache[blockIndex]) {
      T* expectedLayout = new T;
      layoutCache[blockIndex].reset(expectedLayout);
      expectedLayout->mapLayout(layout);
    }
    return reinterpret_cast<T&>(*layoutCache[blockIndex].get());
  }
 
  RecordFileReader* recordFileReader_{};
 
  // Keep the readers all separate,
  // in case the same RecordFormatStreamPlayer is handling multiple streams.
  map<tuple<StreamId, Record::Type, uint32_t>, RecordFormatReader> readers_;
  map<pair<StreamId, Record::Type>, RecordFormatReader*> lastReader_;
  RecordFormatReader* currentReader_{};
};
 
} // namespace vrs