Compressor.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 <memory>
#include <string>
#include <vector>
 
#include "ForwardDefinitions.h"
#include "WriteFileHandler.h"
 
namespace vrs {
 
enum class CompressionPreset {
  Undefined = -1, 
  None = 0, 
  Lz4Fast, 
  Lz4Tight, 
 
  ZstdFaster,
  ZstdFast,
  ZstdLight,
  ZstdMedium,
  ZstdHeavy,
  ZstdHigh,
  ZstdTight,
  ZstdMax,
 
  COUNT,
 
  FirstLz4Preset = Lz4Fast,
  LastLz4Preset = Lz4Tight,
 
  FirstZstdPreset = ZstdFaster,
  LastZstdPreset = ZstdMax,
 
  CompressedFirst = Lz4Fast,
  CompressedLast = ZstdMax,
 
  Default = ZstdFaster 
 
};
 
std::string toPrettyName(CompressionPreset preset);
std::string toString(CompressionPreset preset);
template <>
CompressionPreset toEnum<CompressionPreset>(const std::string& presetName);
 
std::string toString(CompressionType compressionType);
template <>
CompressionType toEnum<CompressionType>(const std::string& compressionTypeName);
 
class Compressor {
 public:
  static const size_t kMinByteCountForCompression; // don't try to compress small payloads
 
  Compressor();
  ~Compressor();
 
  uint32_t
  compress(const void* data, size_t dataSize, CompressionPreset preset, size_t headerSpace = 0);
 
  int startFrame(size_t frameSize, CompressionPreset zstdPreset, uint32_t& outSize);
  int addFrameData(
      WriteFileHandler& file,
      const void* data,
      size_t dataSize,
      uint32_t& inOutCompressedSize,
      size_t maxCompressedSize = 0);
  int endFrame(WriteFileHandler& file, uint32_t& inOutCompressedSize, size_t maxCompressedSize = 0);
 
  const void* getData() const {
    return buffer_.data();
  }
  template <class HeaderType>
  HeaderType* getHeader() {
    return reinterpret_cast<HeaderType*>(buffer_.data());
  }
  CompressionType getCompressionType() const;
 
  void clear() {
    std::vector<uninitialized_byte> blank;
    buffer_.swap(blank);
  }
 
  static bool shouldTryToCompress(CompressionPreset preset, size_t size);
 
  struct uninitialized_byte final {
    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init, modernize-use-equals-default)
    uninitialized_byte() {} // do not use '= default' as it will initialize byte!
    uint8_t byte;
  };
 
 private:
  class CompressorImpl;
  std::unique_ptr<CompressorImpl> impl_;
  std::vector<uninitialized_byte> buffer_;
};
 
} // namespace vrs