tor-browser

padded_bytes.h (6302B)

---

// Copyright (c) the JPEG XL Project Authors. All rights reserved.
//
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

#ifndef LIB_JXL_BASE_PADDED_BYTES_H_
#define LIB_JXL_BASE_PADDED_BYTES_H_

// std::vector replacement with padding to reduce bounds checks in WriteBits

#include <jxl/memory_manager.h>

#include <algorithm>  // max
#include <cstddef>
#include <cstdint>
#include <cstring>  // memcpy
#include <initializer_list>
#include <utility>  // swap

#include "lib/jxl/base/status.h"
#include "lib/jxl/memory_manager_internal.h"

namespace jxl {

// Provides a subset of the std::vector interface with some differences:
// - allows BitWriter to write 64 bits at a time without bounds checking;
// - ONLY zero-initializes the first byte (required by BitWriter);
// - ensures cache-line alignment.
class PaddedBytes {
public:
 // Required for output params.
 explicit PaddedBytes(JxlMemoryManager* memory_manager)
     : memory_manager_(memory_manager), size_(0), capacity_(0) {}

 static StatusOr<PaddedBytes> WithInitialSpace(
     JxlMemoryManager* memory_manager, size_t size) {
   PaddedBytes result(memory_manager);
   JXL_RETURN_IF_ERROR(result.Init(size));
   return result;
 }

 // Deleting copy constructor and copy assignment operator to prevent copying
 PaddedBytes(const PaddedBytes&) = delete;
 PaddedBytes& operator=(const PaddedBytes&) = delete;

 // default is not OK - need to set other.size_ to 0!
 PaddedBytes(PaddedBytes&& other) noexcept
     : memory_manager_(other.memory_manager_),
       size_(other.size_),
       capacity_(other.capacity_),
       data_(std::move(other.data_)) {
   other.size_ = other.capacity_ = 0;
 }
 PaddedBytes& operator=(PaddedBytes&& other) noexcept {
   memory_manager_ = other.memory_manager_;
   size_ = other.size_;
   capacity_ = other.capacity_;
   data_ = std::move(other.data_);

   if (&other != this) {
     other.size_ = other.capacity_ = 0;
   }
   return *this;
 }

 JxlMemoryManager* memory_manager() const { return memory_manager_; }

 void swap(PaddedBytes& other) noexcept {
   std::swap(memory_manager_, other.memory_manager_);
   std::swap(size_, other.size_);
   std::swap(capacity_, other.capacity_);
   std::swap(data_, other.data_);
 }

 // If current capacity is greater than requested, then no-op. Otherwise
 // copies existing data to newly allocated "data_".
 // The new capacity will be at least 1.5 times the old capacity. This ensures
 // that we avoid quadratic behaviour.
 Status reserve(size_t capacity) {
   if (capacity <= capacity_) return true;

   size_t new_capacity = std::max(capacity, 3 * capacity_ / 2);
   new_capacity = std::max<size_t>(64, new_capacity);

   // BitWriter writes up to 7 bytes past the end.
   JXL_ASSIGN_OR_RETURN(
       AlignedMemory new_data,
       AlignedMemory::Create(memory_manager_, new_capacity + 8));

   if (data_.address<void>() == nullptr) {
     // First allocation: ensure first byte is initialized (won't be copied).
     new_data.address<uint8_t>()[0] = 0;
   } else {
     // Subsequent resize: copy existing data to new location.
     memmove(new_data.address<void>(), data_.address<void>(), size_);
     // Ensure that the first new byte is initialized, to allow write_bits to
     // safely append to the newly-resized PaddedBytes.
     new_data.address<uint8_t>()[size_] = 0;
   }

   capacity_ = new_capacity;
   data_ = std::move(new_data);
   return true;
 }

 // NOTE: unlike vector, this does not initialize the new data!
 // However, we guarantee that write_bits can safely append after
 // the resize, as we zero-initialize the first new byte of data.
 // If size < capacity(), does not invalidate the memory.
 Status resize(size_t size) {
   JXL_RETURN_IF_ERROR(reserve(size));
   size_ = size;
   return true;
 }

 // resize(size) plus explicit initialization of the new data with `value`.
 Status resize(size_t size, uint8_t value) {
   size_t old_size = size_;
   JXL_RETURN_IF_ERROR(resize(size));
   if (size_ > old_size) {
     memset(data() + old_size, value, size_ - old_size);
   }
   return true;
 }

 // Amortized constant complexity due to exponential growth.
 Status push_back(uint8_t x) {
   if (size_ == capacity_) {
     JXL_RETURN_IF_ERROR(reserve(capacity_ + 1));
   }

   data_.address<uint8_t>()[size_++] = x;
   return true;
 }

 size_t size() const { return size_; }
 size_t capacity() const { return capacity_; }

 uint8_t* data() { return data_.address<uint8_t>(); }
 const uint8_t* data() const { return data_.address<uint8_t>(); }

 // std::vector operations implemented in terms of the public interface above.

 void clear() {
   // Not passing on the Status, because resizing to 0 cannot fail.
   static_cast<void>(resize(0));
 }
 bool empty() const { return size() == 0; }

 Status assign(std::initializer_list<uint8_t> il) {
   JXL_RETURN_IF_ERROR(resize(il.size()));
   memcpy(data(), il.begin(), il.size());
   return true;
 }

 uint8_t* begin() { return data(); }
 const uint8_t* begin() const { return data(); }
 uint8_t* end() { return begin() + size(); }
 const uint8_t* end() const { return begin() + size(); }

 uint8_t& operator[](const size_t i) {
   BoundsCheck(i);
   return data()[i];
 }
 const uint8_t& operator[](const size_t i) const {
   BoundsCheck(i);
   return data()[i];
 }

 template <typename T>
 Status append(const T& other) {
   return append(
       reinterpret_cast<const uint8_t*>(other.data()),
       reinterpret_cast<const uint8_t*>(other.data()) + other.size());
 }

 Status append(const uint8_t* begin, const uint8_t* end) {
   if (end - begin > 0) {
     size_t old_size = size();
     JXL_RETURN_IF_ERROR(resize(size() + (end - begin)));
     memcpy(data() + old_size, begin, end - begin);
   }
   return true;
 }

private:
 Status Init(size_t size) {
   size_ = size;
   return reserve(size);
 }

 void BoundsCheck(size_t i) const {
   // <= is safe due to padding and required by BitWriter.
   JXL_DASSERT(i <= size());
 }

 JxlMemoryManager* memory_manager_;
 size_t size_;
 size_t capacity_;
 AlignedMemory data_;
};

}  // namespace jxl

#endif  // LIB_JXL_BASE_PADDED_BYTES_H_