PcmBufferWriter.hpp

#ifndef ZAO_ENDPOINT_AUDIO_PCM_BUFFER_WRITER_HPP_
#define ZAO_ENDPOINT_AUDIO_PCM_BUFFER_WRITER_HPP_
 
#include <cstddef>
#include <cstdint>
#include <memory>
 
#include "../TimestampInterface.hpp"
 
namespace zao {
namespace endpoint {
namespace audio {
 
class PcmBufferPoolInterface;
 
class PcmBufferWriter final {
 public:
  PcmBufferWriter() noexcept {}
 
  PcmBufferWriter(const std::weak_ptr<PcmBufferPoolInterface>& pool_weak,
                  std::int16_t* pointer, std::size_t writable_samples) noexcept
      : pool_weak_(pool_weak),
        pointer_(pointer),
        writable_samples_(writable_samples) {}
 
  PcmBufferWriter(PcmBufferWriter&& other) noexcept {
    *this = std::move(other);
  }
 
  PcmBufferWriter& operator=(PcmBufferWriter&& other) noexcept {
    Cancel();
    std::swap(pool_weak_, other.pool_weak_);
    std::swap(pointer_, other.pointer_);
    std::swap(writable_samples_, other.writable_samples_);
    return *this;
  }
 
  // コピー構築禁止
  PcmBufferWriter(const PcmBufferWriter&) = delete;
 
  // コピー代入禁止
  PcmBufferWriter& operator=(const PcmBufferWriter&) = delete;
 
  ~PcmBufferWriter() noexcept { Cancel(); }
 
  bool IsValid() const noexcept { return !!pointer_; }
 
  explicit operator bool() const noexcept { return IsValid(); }
 
  std::int16_t* GetPointer() const noexcept { return pointer_; }
 
  std::size_t GetWritableSamples() const noexcept { return writable_samples_; }
 
  inline void Finalize(std::size_t written_samples,
                       TimestampInterface::Rep head_timestamp) noexcept;
 
  void Cancel() noexcept { Finalize(0, 0); }
 
 private:
  std::weak_ptr<PcmBufferPoolInterface> pool_weak_;
  std::int16_t* pointer_ = nullptr;
  std::size_t writable_samples_ = 0;
};
 
}  // namespace audio
}  // namespace endpoint
}  // namespace zao
 
#include "PcmBufferPoolInterface.hpp"
 
inline void zao::endpoint::audio::PcmBufferWriter::Finalize(
    std::size_t written_samples,
    TimestampInterface::Rep head_timestamp) noexcept {
  if (!pointer_) {
    return;
  }
  if (auto pool = pool_weak_.lock()) {
    pool->FinalizeWriter(*this, written_samples, head_timestamp);
  }
  pool_weak_.reset();
  pointer_ = nullptr;
  writable_samples_ = 0;
}
 
#endif  // ZAO_ENDPOINT_AUDIO_PCM_BUFFER_WRITER_HPP_