buffer.h

Go to the documentation of this file.

#pragma once
 
#include "avcpp/averror.h"
#include "ffmpeg.h"
 
#if AVCPP_CXX_STANDARD >= 20
#include <span>
#endif // AVCPP_CXX_STANDARD >= 20
 
namespace av {
 
namespace buffer {
void null_deleter(void* /*opaque*/, uint8_t* /*data*/);
} // ::buffer
 
class BufferRef;
 
class BufferRefView : public FFWrapperPtr<AVBufferRef>
{
public:
    using FFWrapperPtr<AVBufferRef>::FFWrapperPtr;
 
    BufferRefView() = default;
 
    explicit BufferRefView(BufferRef& ref);
    explicit BufferRefView(const BufferRef& ref);
 
    struct iam_sure_what_i_do_tag{};
    AVBufferRef* makeRef(iam_sure_what_i_do_tag) const noexcept;
 
    BufferRef ref();
 
    BufferRef clone(int flags = 0) const noexcept;
 
    int refCount() const noexcept;
    bool isWritable() const noexcept;
 
    std::size_t size() const noexcept;
    const uint8_t* data() const noexcept;
    const uint8_t* constData() const noexcept;
    uint8_t* data(OptionalErrorCode ec = throws());
 
#if AVCPP_CXX_STANDARD >= 20
    std::span<const uint8_t> span() const noexcept;
    std::span<const uint8_t> constSpan() const noexcept;
    std::span<uint8_t> span(OptionalErrorCode ec = throws());
#endif
};
 
 
class BufferRef : public BufferRefView
{
    //using FFWrapperPtr<AVBufferRef>::FFWrapperPtr;
    using BufferRefView::BufferRefView;
 
public:
    BufferRef() = default;
 
    BufferRef(std::size_t size, bool keepUninit = true) noexcept;
 
    BufferRef(uint8_t *data, size_t size, void (*free)(void *opaque, uint8_t *data), void *opaque, int flags = 0) noexcept;
 
    BufferRef(const uint8_t *data, size_t size, void (*free)(void *opaque, uint8_t *data), void *opaque, int flags = 0) noexcept;
 
    BufferRef(const uint8_t *data, size_t size, int flags = 0) noexcept;
 
#if AVCPP_CXX_STANDARD
    BufferRef(std::span<uint8_t> data, void (*free)(void *opaque, uint8_t *data), void *opaque, int flags = 0) noexcept;
 
    explicit BufferRef(std::span<const uint8_t> data, int flags = 0) noexcept;
#endif // AVCPP_CXX_STANDARD
 
    BufferRef(const BufferRef& other) noexcept;
    BufferRef(BufferRef&& other) noexcept;
 
    ~BufferRef() noexcept;
 
    BufferRef& operator=(const BufferRef& other) noexcept;
    BufferRef& operator=(BufferRef&& other) noexcept;
 
    static BufferRef wrap(const AVBufferRef *buf, int flags = 0) noexcept;
    static BufferRef wrap(AVBufferRef *buf) noexcept;
    static BufferRef ref(const AVBufferRef *buf) noexcept;
 
    using BufferRefView::ref;
 
    AVBufferRef* release() noexcept;
 
    void reset() noexcept;
 
    void makeWritable(OptionalErrorCode ec = throws());
    void resize(std::size_t size, OptionalErrorCode ec = throws());
 
    void swap(BufferRef &other) noexcept;
};
 
} // ::av