NvSourceBufferDequeueResult.hpp

#ifndef ZAO_ENDPOINT_VIDEO_NV_SOURCE_BUFFER_DEQUEUE_RESULT_HPP_
#define ZAO_ENDPOINT_VIDEO_NV_SOURCE_BUFFER_DEQUEUE_RESULT_HPP_
 
#include <memory>
 
#include "NvBufferInterface.hpp"
 
namespace zao {
namespace endpoint {
namespace video {
 
class NvSourceBufferDequeueResult {
 public:
  enum class ErrorType {
    kNone,
 
    kAborted,
 
    kNotConfigured,
 
    kInvalidFormat,
 
    kNoEncoder,
 
    kEncoderInternal,
  };
 
 public:
  NvSourceBufferDequeueResult(
      std::unique_ptr<NvBufferInterface> buffer) noexcept
      : buffer_(std::move(buffer)) {}
 
  NvSourceBufferDequeueResult(ErrorType error) noexcept : error_(error) {}
 
  NvSourceBufferDequeueResult(const NvSourceBufferDequeueResult&) = delete;
 
  NvSourceBufferDequeueResult& operator=(const NvSourceBufferDequeueResult&) =
      delete;
 
  NvSourceBufferDequeueResult(NvSourceBufferDequeueResult&& other) noexcept =
      default;
 
  NvSourceBufferDequeueResult& operator=(
      NvSourceBufferDequeueResult&& other) noexcept = default;
 
  std::unique_ptr<NvBufferInterface> TakeBuffer() noexcept {
    return std::move(buffer_);
  }
 
  bool HasError() const noexcept { return error_ != ErrorType::kNone; }
 
  bool HasAbortedError() const noexcept {
    return error_ == ErrorType::kAborted;
  }
 
  bool HasNotConfiguredError() const noexcept {
    return error_ == ErrorType::kNotConfigured;
  }
 
  bool HasInvalidFormatError() const noexcept {
    return error_ == ErrorType::kInvalidFormat;
  }
 
  bool HasNoEncoderError() const noexcept {
    return error_ == ErrorType::kNoEncoder;
  }
 
  bool HasEncoderInternalError() const noexcept {
    return error_ == ErrorType::kEncoderInternal;
  }
 
  const char* What() const noexcept {
    switch (error_) {
      case ErrorType::kNone:
        return "No error.";
      case ErrorType::kAborted:
        return "Aborted by FlushQueue.";
      case ErrorType::kNotConfigured:
        return "Queue is not configured.";
      case ErrorType::kInvalidFormat:
        return "Invalid or unsupported format.";
      case ErrorType::kNoEncoder:
        return "Encoder is absent.";
      case ErrorType::kEncoderInternal:
        return "Internal error of encoder.";
      default:
        return "Unknown error.";
    }
  }
 
 private:
  std::unique_ptr<NvBufferInterface> buffer_;
  ErrorType error_ = ErrorType::kNone;
};
 
}  // namespace video
}  // namespace endpoint
}  // namespace zao
 
#endif  // ZAO_ENDPOINT_VIDEO_NV_SOURCE_BUFFER_DEQUEUE_RESULT_HPP_