host_buffer.cc

Go to the documentation of this file.

// Copyright 2013 The Flutter Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
 
#include "impeller/core/host_buffer.h"
 
#include <algorithm>
#include <cstring>
 
#include "flutter/fml/logging.h"
 
#include "impeller/core/allocator.h"
#include "impeller/core/buffer_view.h"
#include "impeller/core/device_buffer.h"
 
namespace impeller {
 
std::shared_ptr<HostBuffer> HostBuffer::Create() {
  return std::shared_ptr<HostBuffer>(new HostBuffer());
}
 
HostBuffer::HostBuffer() = default;
 
HostBuffer::~HostBuffer() = default;
 
void HostBuffer::SetLabel(std::string label) {
  state_->label = std::move(label);
}
 
BufferView HostBuffer::Emplace(const void* buffer,
                               size_t length,
                               size_t align) {
  auto [device_buffer, range] = state_->Emplace(buffer, length, align);
  if (!device_buffer) {
    return {};
  }
  return BufferView{state_, device_buffer, range};
}
 
BufferView HostBuffer::Emplace(const void* buffer, size_t length) {
  auto [device_buffer, range] = state_->Emplace(buffer, length);
  if (!device_buffer) {
    return {};
  }
  return BufferView{state_, device_buffer, range};
}
 
BufferView HostBuffer::Emplace(size_t length,
                               size_t align,
                               const EmplaceProc& cb) {
  auto [buffer, range] = state_->Emplace(length, align, cb);
  if (!buffer) {
    return {};
  }
  return BufferView{state_, buffer, range};
}
 
std::shared_ptr<const DeviceBuffer> HostBuffer::GetDeviceBuffer(
    Allocator& allocator) const {
  return state_->GetDeviceBuffer(allocator);
}
 
void HostBuffer::Reset() {
  state_->Reset();
}
 
size_t HostBuffer::GetSize() const {
  return state_->GetReservedLength();
}
 
size_t HostBuffer::GetLength() const {
  return state_->GetLength();
}
 
std::pair<uint8_t*, Range> HostBuffer::HostBufferState::Emplace(
    size_t length,
    size_t align,
    const EmplaceProc& cb) {
  if (!cb) {
    return {};
  }
  auto old_length = GetLength();
  if (!Truncate(old_length + length)) {
    return {};
  }
  generation++;
  cb(GetBuffer() + old_length);
 
  return std::make_pair(GetBuffer(), Range{old_length, length});
}
 
std::shared_ptr<const DeviceBuffer>
HostBuffer::HostBufferState::GetDeviceBuffer(Allocator& allocator) const {
  if (generation == device_buffer_generation) {
    return device_buffer;
  }
  auto new_buffer = allocator.CreateBufferWithCopy(GetBuffer(), GetLength());
  if (!new_buffer) {
    return nullptr;
  }
  new_buffer->SetLabel(label);
  device_buffer_generation = generation;
  device_buffer = std::move(new_buffer);
  return device_buffer;
}
 
std::pair<uint8_t*, Range> HostBuffer::HostBufferState::Emplace(
    const void* buffer,
    size_t length) {
  auto old_length = GetLength();
  if (!Truncate(old_length + length)) {
    return {};
  }
  generation++;
  if (buffer) {
    ::memmove(GetBuffer() + old_length, buffer, length);
  }
  return std::make_pair(GetBuffer(), Range{old_length, length});
}
 
std::pair<uint8_t*, Range> HostBuffer::HostBufferState::Emplace(
    const void* buffer,
    size_t length,
    size_t align) {
  if (align == 0 || (GetLength() % align) == 0) {
    return Emplace(buffer, length);
  }
 
  {
    auto [buffer, range] = Emplace(nullptr, align - (GetLength() % align));
    if (!buffer) {
      return {};
    }
  }
 
  return Emplace(buffer, length);
}
 
void HostBuffer::HostBufferState::Reset() {
  generation += 1;
  device_buffer = nullptr;
  bool did_truncate = Truncate(0);
  FML_CHECK(did_truncate);
}
 
}  // namespace impeller