frame.h

Go to the documentation of this file.

#pragma once
 
#include <vector>
 
#include "avcompat.h"
#include "avcpp/buffer.h"
#include "avcpp/dictionary.h"
 
#if AVCPP_CXX_STANDARD >= 20
#if __has_include(<span>)
#include <span>
#endif
#endif
 
#include "ffmpeg.h"
#include "rational.h"
#include "timestamp.h"
#include "pixelformat.h"
#include "sampleformat.h"
 
extern "C" {
#include <libavutil/imgutils.h>
#include <libavutil/attributes.h>
}
 
namespace av
{
 
namespace frame
{
int64_t get_best_effort_timestamp(const AVFrame* frame);
uint64_t get_channel_layout(const AVFrame* frame);
void set_channel_layout(AVFrame* frame, uint64_t layout);
} // ::av::frame
 
#if AVCPP_HAS_FRAME_SIDE_DATA
class FrameSideData : public FFWrapperPtr<AVFrameSideData>
{
public:
    using FFWrapperPtr<AVFrameSideData>::FFWrapperPtr;
 
    std::string_view name() const noexcept;
    AVFrameSideDataType type() const noexcept;
    std::span<const uint8_t> span() const noexcept;
    std::span<uint8_t> span() noexcept;
 
    BufferRefView buffer() const noexcept;
 
    Dictionary metadata() const noexcept;
 
    static std::string_view name(AVFrameSideDataType type) noexcept;
 
#if AVCPP_API_HAS_AVSIDEDATADESCRIPTOR
    std::optional<AVSideDataDescriptor> descriptor() const noexcept;
    static std::optional<AVSideDataDescriptor> descriptor(AVFrameSideDataType type) noexcept;
#endif // AVCPP_API_HAS_AVSIDEDATADESCRIPTOR
 
    bool empty() const noexcept;
    operator bool() const noexcept;
};
#endif // AVCPP_HAS_PKT_SIDE_DATA
 
class FrameCommon : public FFWrapperPtr<AVFrame>
{
public:
    struct wrap_data {};
    struct wrap_data_static {};
 
    FrameCommon();
    FrameCommon(const AVFrame *frame);
 
    // Helper ctors to implement move/copy ctors
    FrameCommon(const FrameCommon& other);
    FrameCommon(FrameCommon&& other);
 
    ~FrameCommon();
 
    bool isReferenced() const;
    int refCount() const;
    AVFrame* makeRef() const;
 
    Timestamp pts() const;
    attribute_deprecated void setPts(int64_t pts, Rational ptsTimeBase);
    void setPts(const Timestamp &ts);
 
    const Rational& timeBase() const;
    void setTimeBase(const Rational &value);
 
    int streamIndex() const;
    void setStreamIndex(int streamIndex);
 
    void setComplete(bool isComplete);
    bool isComplete() const;
 
    bool isValid() const;
 
    operator bool() const;
 
    uint8_t *data(size_t plane = 0);
    const uint8_t *data(size_t plane = 0) const;
 
    size_t size(size_t plane) const;
    size_t size() const;
 
    void dump() const;
 
    // You must implement operators in deveritive classes using assignOperator() and moveOperator()
    void operator=(const FrameCommon&) = delete;
 
    void swap(FrameCommon &other);
 
#if AVCPP_HAS_FRAME_SIDE_DATA
    const FrameSideData sideData(AVFrameSideDataType type) const;
    FrameSideData       sideData(AVFrameSideDataType type);
 
    std::size_t sideDataCount() const noexcept;
 
    FrameSideData sideDataIndex(std::size_t index) noexcept;
 
    ArrayView<AVFrameSideData*, FrameSideData, std::size_t> sideData() noexcept;
    ArrayView<const AVFrameSideData*, FrameSideData, std::size_t> sideData() const noexcept;
 
 
    void sideDataRemove(AVFrameSideDataType type) noexcept;
 
    FrameSideData addSideData(AVFrameSideDataType type, std::span<const uint8_t> data, OptionalErrorCode ec = throws());
 
    FrameSideData addSideData(AVFrameSideDataType type, std::span<uint8_t> data, wrap_data, OptionalErrorCode ec = throws());
 
    FrameSideData addSideData(AVFrameSideDataType type, std::span<uint8_t> data, wrap_data_static, OptionalErrorCode ec = throws());
 
    FrameSideData addSideData(AVFrameSideDataType type, BufferRef buf, OptionalErrorCode ec = throws());
 
    FrameSideData allocateSideData(AVFrameSideDataType type, std::size_t size, OptionalErrorCode ec = throws());
#endif
 
protected:
    void copyInfoFrom(const FrameCommon& other);
    void clone(FrameCommon& dst, size_t align = 1) const;
 
protected:
    Rational             m_timeBase{};
    int                  m_streamIndex {-1};
    bool                 m_isComplete  {false};
};
 
template<typename T>
class Frame : public FrameCommon
{
protected:
    T& assignOperator(const T &rhs) {
        if (this == &rhs)
            return static_cast<T&>(*this);
        T(rhs).swap(static_cast<T&>(*this));
        return static_cast<T&>(*this);
    }
 
    T& moveOperator(T &&rhs) {
        if (this == &rhs)
            return static_cast<T&>(*this);
        T(std::move(rhs)).swap(static_cast<T&>(*this));
        return static_cast<T&>(*this);
    }
 
public:
    using FrameCommon::FrameCommon;
 
    static T null() {
        return T(nullptr);
    }
 
    T clone(size_t align = 1) const {
        T result;
        FrameCommon::clone(result, align);
        return result;
    }
};
 
static_assert(std::is_copy_assignable_v<FrameCommon> == false);
static_assert(std::is_copy_constructible_v<FrameCommon> == true);
static_assert(std::is_move_assignable_v<FrameCommon> == false);
static_assert(std::is_move_constructible_v<FrameCommon> == true);
 
class VideoFrame : public Frame<VideoFrame>
{
public:
    using Frame<VideoFrame>::Frame;
 
    VideoFrame() = default;
    VideoFrame(PixelFormat pixelFormat, int width, int height, int align = 1);
    VideoFrame(const uint8_t *data, size_t size, PixelFormat pixelFormat, int width, int height, int align = 1);
 
    VideoFrame(const VideoFrame &other);
    VideoFrame(VideoFrame &&other);
 
    VideoFrame& operator=(const VideoFrame &rhs);
    VideoFrame& operator=(VideoFrame &&rhs);
 
    PixelFormat            pixelFormat() const;
    int                    width() const;
    int                    height() const;
 
    PixelFormat            adjustFromJpegPixelFormat();
    PixelFormat            adjustToJpegPixelFormat();
 
    bool                   isKeyFrame() const;
    void                   setKeyFrame(bool isKey);
 
    int                    quality() const;
    void                   setQuality(int quality);
 
    AVPictureType          pictureType() const;
    void                   setPictureType(AVPictureType type = AV_PICTURE_TYPE_NONE);
 
    Rational               sampleAspectRatio() const;
    void                   setSampleAspectRatio(const Rational& sampleAspectRatio);
 
    size_t                 bufferSize(int align = 1, OptionalErrorCode ec = throws()) const;
    bool                   copyToBuffer(uint8_t *dst, size_t size, int align = 1, OptionalErrorCode ec = throws());
    bool                   copyToBuffer(std::vector<uint8_t>& dst, int align = 1, OptionalErrorCode ec = throws());
 
 
    static VideoFrame wrap(const void *data, size_t size, PixelFormat pixelFormat, int width, int height, int align = 1);
 
#if AVCPP_CXX_STANDARD >= 20
    static VideoFrame wrap(std::span<const std::byte> data, PixelFormat pixelFormat, int width, int height, int align = 1);
 
    static VideoFrame wrap(std::span<const std::byte> data, void (*deleter)(void *opaque, uint8_t *data),
                           void *opaque, PixelFormat pixelFormat, int width, int height, int align = 1);
#endif
};
 
static_assert(std::is_copy_assignable_v<VideoFrame> == true);
static_assert(std::is_copy_constructible_v<VideoFrame> == true);
static_assert(std::is_move_assignable_v<VideoFrame> == true);
static_assert(std::is_move_constructible_v<VideoFrame> == true);
 
class AudioSamples : public Frame<AudioSamples>
{
public:
    using Frame<AudioSamples>::Frame;
 
    AudioSamples() = default;
    AudioSamples(SampleFormat sampleFormat, int samplesCount, uint64_t channelLayout, int sampleRate, int align = SampleFormat::AlignDefault);
    AudioSamples(const uint8_t *data, size_t size,
                  SampleFormat sampleFormat, int samplesCount, uint64_t channelLayout, int sampleRate, int align = SampleFormat::AlignDefault);
 
    AudioSamples(const AudioSamples &other);
    AudioSamples(AudioSamples &&other);
 
    AudioSamples& operator=(const AudioSamples &rhs);
    AudioSamples& operator=(AudioSamples &&rhs);
 
    int            init(SampleFormat sampleFormat, int samplesCount, uint64_t channelLayout, int sampleRate, int align = SampleFormat::AlignDefault);
 
    SampleFormat   sampleFormat() const;
    int            samplesCount() const;
    int            channelsCount() const;
    uint64_t       channelsLayout() const;
    int            sampleRate() const;
    size_t         sampleBitDepth(OptionalErrorCode ec = throws()) const;
    bool           isPlanar() const;
 
    std::string    channelsLayoutString() const;
};
 
static_assert(std::is_copy_assignable_v<AudioSamples> == true);
static_assert(std::is_copy_constructible_v<AudioSamples> == true);
static_assert(std::is_move_assignable_v<AudioSamples> == true);
static_assert(std::is_move_constructible_v<AudioSamples> == true);
 
 
} // ::av