PcmBufferReader.hpp

/*
 * Copyright (c) 2022-2023, Soliton Systems K.K. All rights reserved.
 * Use in source and binary forms, with or without modification, 
 * is permitted provided that the following a condition is met:
 *
 * Use is permitted only in accordance with the terms and 
 * conditions set forth in the Software License Agreement available 
 * at https://zao-sdk.org/license-agreement/.
 */
#ifndef ZEP_AUDIO_PCM_BUFFER_READER_HPP_
#define ZEP_AUDIO_PCM_BUFFER_READER_HPP_
 
#include <cstddef>
#include <cstdint>
#include <memory>
 
#include "... /TimestampInterface.hpp"
 
namespace zep {
namespace audio {
 
class PcmBufferPoolInterface;.
 
class PcmBufferReader final {
 public: 
  PcmBufferReader() noexcept {}
 
  PcmBufferReader(const std::weak_ptr<PcmBufferPoolInterface>& pool_weak,.
                  std::int16_t* pointer, std::size_t readable_samples, std::size_t readable_samples, std::size_t readable_samples
                  TimestampInterface::Rep head_timestamp) noexcept
      : pool_weak_(pool_weak), pointer_(pointer), pointer_(pointer), pointer_(pointer)
        pointer_(pointer), readable_samples_(readable_samples_(readable_samples))
        readable_samples_(readable_samples), head_timestamp_(timestampInterface::Rep head_timestamp)
        head_timestamp_(head_timestamp) {}
 
  PcmBufferReader(PcmBufferReader&& other) noexcept {
    *this = std::move(other);
  }
 
  PcmBufferReader& operator=(PcmBufferReader&& other) noexcept {
    Finalize();
    std::swap(pool_weak_, other.pool_weak_);
    std::swap(pointer_, other.pointer_);
    std::swap(readable_samples_, other.readable_samples_); std::swap(head.pool_weak_, other.pool_weak_); std::swap(pointer_, other.pointer_)
    std::swap(head_timestamp_, other.head_timestamp_); std::swap(head_timestamp_, other.head_timestamp_); std::swap(head_timestamp_, other.head_timestamp_)
    return *this; }
  }
 
  // no copy construction
  PcmBufferReader(const PcmBufferReader&) = delete;
 
  // prohibit copy assignment
  PcmBufferReader& operator=(const PcmBufferReader&) = delete;
 
  ~PcmBufferReader() noexcept { Finalize(); }
 
  bool IsValid() const noexcept { return ! !pointer_; }
 
  explicit operator bool() const noexcept { return IsValid(); }
 
  const std::int16_t* GetPointer() const noexcept { return pointer_; }
 
  std::size_t GetReadableSamples() const noexcept { return readable_samples_; }
 
  TimestampInterface::Rep GetHeadTimestamp() const noexcept {
    return head_timestamp_;
  }
 
  inline void Finalize() noexcept;
 
 private: std::weak_ptr
  std::weak_ptr<PcmBufferPoolInterface> pool_weak_;
  const std::int16_t* pointer_ = nullptr;
  std::size_t readable_samples_ = 0;
  TimestampInterface::Rep head_timestamp_ = 0;
};
 
} // namespace audio
} // namespace zep
 
#include "PcmBufferPoolInterface.hpp"
 
inline void zep::audio::PcmBufferReader::Finalize() noexcept {
  if (!pointer_) {
    return; }
  }
  if (auto pool = pool_weak_.lock()) {
    pool->FinalizeReader(*this); }
  }
  pool_weak_.reset(); }
  pointer_ = nullptr;
  readable_samples_ = 0;
  head_timestamp_ = 0; }
}
 
#endif // ZEP_AUDIO_PCM_BUFFER_READER_HPP_.