FileFormat.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 "Record.h"
 
 
namespace vrs {
 
namespace FileFormat {
#pragma pack(push, 1)
 
template <class T>
class LittleEndian final {
 public:
  LittleEndian() = default;
 
  explicit LittleEndian(T value) {
    set(value);
  }
 
  T get() const {
    return value_;
  }
  void set(T value) {
    value_ = value;
  }
 
 private:
  T value_{};
};
 
struct FileHeader {
  LittleEndian<uint32_t> magicHeader1; 
  LittleEndian<uint32_t> magicHeader2; 
  LittleEndian<uint64_t> creationId; 
  LittleEndian<uint32_t> fileHeaderSize; 
  LittleEndian<uint32_t> recordHeaderSize; 
  LittleEndian<int64_t> indexRecordOffset; 
  LittleEndian<int64_t> descriptionRecordOffset; 
  LittleEndian<int64_t>
      firstUserRecordOffset; 
  LittleEndian<uint64_t> future2; 
  LittleEndian<uint64_t> future3; 
  LittleEndian<uint64_t> future4; 
  LittleEndian<uint32_t> magicHeader3; 
  LittleEndian<uint32_t> fileFormatVersion; 
 
  void init();
  void init(uint32_t magic1, uint32_t magic2, uint32_t magic3, uint32_t formatVersion);
  bool looksLikeAVRSFile() const;
  bool looksLikeOurFiles(uint32_t magic1, uint32_t magic2, uint32_t magic3) const;
  bool isFormatSupported() const;
  void enableFrontIndexRecordSupport();
  int64_t getEndOfUserRecordsOffset(int64_t fileSize) const;
};
 
// Re-interpret legacy recordable Type id
RecordableTypeId readRecordableTypeId(const FileFormat::LittleEndian<int32_t>& recordableTypeId);
 
struct RecordHeader {
  RecordHeader();
  RecordHeader(
      Record::Type recordType,
      StreamId streamId,
      double timestamp,
      uint32_t formatVersion,
      CompressionType compressionType,
      uint32_t previousRecordSize,
      uint32_t recordSize,
      uint32_t uncompressedSize);
  LittleEndian<uint32_t> recordSize; 
  LittleEndian<uint32_t> previousRecordSize; 
  LittleEndian<int32_t> recordableTypeId; 
  LittleEndian<uint32_t> formatVersion; 
  LittleEndian<double> timestamp; 
  LittleEndian<uint16_t> recordableInstanceId; 
  LittleEndian<uint8_t> recordType; 
  LittleEndian<uint8_t> compressionType; 
  LittleEndian<uint32_t>
      uncompressedSize; 
 
  void setRecordType(Record::Type type) {
    recordType.set(static_cast<uint8_t>(type));
  }
 
  Record::Type getRecordType() const {
    return static_cast<Record::Type>(recordType.get());
  }
 
  void setRecordableTypeId(RecordableTypeId typeId) {
    recordableTypeId.set(static_cast<int32_t>(typeId));
  }
 
  RecordableTypeId getRecordableTypeId() const {
    return readRecordableTypeId(recordableTypeId);
  }
 
  StreamId getStreamId() const {
    return {getRecordableTypeId(), recordableInstanceId.get()};
  }
 
  CompressionType getCompressionType() const {
    return static_cast<CompressionType>(compressionType.get());
  }
 
  void setCompressionType(CompressionType type) {
    this->compressionType.set(static_cast<uint8_t>(type));
  }
 
  void initHeader(
      Record::Type recordType,
      StreamId streamId,
      double timestamp,
      uint32_t formatVersion,
      CompressionType compressionType,
      uint32_t previousRecordSize,
      uint32_t recordSize,
      uint32_t uncompressedSize);
 
  void initIndexHeader(
      uint32_t formatVersion,
      uint32_t indexSize,
      uint32_t previousRecordSize,
      CompressionType compressionType);
 
  void initDescriptionHeader(
      uint32_t formatVersion,
      uint32_t descriptionRecordSize,
      uint32_t previousRecordSize);
 
  bool isSanityCheckOk() const;
};
 
#pragma pack(pop)
 
constexpr uint32_t fourCharCode(char a, char b, char c, char d) {
  return static_cast<uint32_t>(a) | (static_cast<uint32_t>(b) << 8) |
      (static_cast<uint32_t>(c) << 16) | (static_cast<uint32_t>(d) << 24);
}
 
bool printVRSFileInternals(std::unique_ptr<FileHandler>& file);
 
} // namespace FileFormat
 
} // namespace vrs