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)
 
struct FileHeader {
  uint32_t magicHeader1{}; 
  uint32_t magicHeader2{}; 
  uint64_t creationId{}; 
  uint32_t fileHeaderSize{}; 
  uint32_t recordHeaderSize{}; 
  int64_t indexRecordOffset{}; 
  int64_t descriptionRecordOffset{}; 
  int64_t
      firstUserRecordOffset{}; 
  uint64_t future2{}; 
  uint64_t future3{}; 
  uint64_t future4{}; 
  uint32_t magicHeader3{}; 
  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(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);
  uint32_t recordSize{}; 
  uint32_t previousRecordSize{}; 
  int32_t recordableTypeId{}; 
  uint32_t formatVersion{}; 
  double timestamp{}; 
  uint16_t recordableInstanceId{}; 
  uint8_t recordType{}; 
  uint8_t compressionType{}; 
  uint32_t uncompressedSize{}; 
 
  inline void setRecordType(Record::Type type) {
    recordType = static_cast<uint8_t>(type);
  }
 
  inline Record::Type getRecordType() const {
    return static_cast<Record::Type>(recordType);
  }
 
  inline void setRecordableTypeId(RecordableTypeId typeId) {
    recordableTypeId = static_cast<int32_t>(typeId);
  }
 
  inline RecordableTypeId getRecordableTypeId() const {
    return readRecordableTypeId(recordableTypeId);
  }
 
  inline StreamId getStreamId() const {
    return {getRecordableTypeId(), static_cast<uint16_t>(recordableInstanceId)};
  }
 
  inline CompressionType getCompressionType() const {
    return static_cast<CompressionType>(compressionType);
  }
 
  inline void setCompressionType(CompressionType type) {
    this->compressionType = 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