avcpp  2.0
Wrapper for the FFmpeg that simplify usage from C++ projects.
ffmpeg.h
Go to the documentation of this file.
1 #pragma once
2 
3 #include <iostream>
4 
5 extern "C"
6 {
7 #include <libavutil/avutil.h>
8 #include <libavutil/parseutils.h>
9 #include <libavutil/mathematics.h>
10 #include <libavutil/opt.h>
11 #include <libavutil/pixdesc.h>
12 #include <libavdevice/avdevice.h>
13 #include <libswscale/swscale.h>
14 #include <libswresample/swresample.h>
15 #include <libavformat/version.h>
16 #include <libavcodec/version.h>
17 }
18 
19 extern "C" {
20 #include <libavfilter/avfilter.h>
21 #if LIBAVFILTER_VERSION_INT < AV_VERSION_INT(7,0,0)
22 # include <libavfilter/avfiltergraph.h>
23 #endif
24 #include <libavfilter/buffersink.h>
25 #include <libavfilter/buffersrc.h>
26 #if LIBAVFILTER_VERSION_INT <= AV_VERSION_INT(2,77,100) // 0.11.1
27 # include <libavfilter/vsrc_buffer.h>
28 #endif
29 #if LIBAVFILTER_VERSION_INT < AV_VERSION_INT(6,31,100) // 3.0
30 #include <libavfilter/avcodec.h>
31 #endif
32 }
33 
34 // Compat level
35 
36 // avcodec
37 #if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(54,59,100) // 1.0
38 inline void avcodec_free_frame(AVFrame **frame)
39 {
40  av_freep(frame);
41 }
42 #endif
43 
44 // avfilter
45 #if LIBAVFILTER_VERSION_INT < AV_VERSION_INT(3,17,100) // 1.0
46 inline const char *avfilter_pad_get_name(AVFilterPad *pads, int pad_idx)
47 {
48  return pads[pad_idx].name;
49 }
50 
51 inline AVMediaType avfilter_pad_get_type(AVFilterPad *pads, int pad_idx)
52 {
53  return pads[pad_idx].type;
54 }
55 #endif
56 
57 
58 // Wrapper around av_free_packet()/av_packet_unref()
59 #if LIBAVFORMAT_VERSION_INT < AV_VERSION_INT(6,31,100) // < 3.0
60 #define avpacket_unref(p) av_free_packet(p)
61 #else
62 #define avpacket_unref(p) av_packet_unref(p)
63 #endif
64 
65 template<typename T>
67 {
68  FFWrapperPtr() = default;
69  explicit FFWrapperPtr(T *raw)
70  : m_raw(raw) {}
71 
72  const T* raw() const { return m_raw; }
73  T* raw() { return m_raw; }
74  void reset(T *raw = nullptr) { m_raw = raw; }
75  bool isNull() const { return (m_raw == nullptr); }
76 
77  void _log(int level, const char *fmt) const
78  {
79  av_log(m_raw, level, fmt);
80  }
81 
82  template<typename... Args>
83  void _log(int level, const char* fmt, const Args&... args) const
84  {
85  av_log(m_raw, level, fmt, args...);
86  }
87 
88 protected:
89  T *m_raw = nullptr;
90 };
91 
92 #define RAW_GET(field, def) (m_raw ? m_raw->field : (def))
93 #define RAW_SET(field, val) if(m_raw) m_raw->field = (val)
94 
95 #define RAW_GET2(cond, field, def) (m_raw && (cond) ? m_raw->field : def)
96 #define RAW_SET2(cond, field, val) if(m_raw && (cond)) m_raw->field = (val)
97 
98 #define IF_GET(ptr, field, def) ((ptr) ? ptr->field : def)
99 #define IF_SET(ptr, field, val) (if(ptr) ptr->field = (val))
100 
101 #define IF_GET2(cond, ptr, field, def) (ptr && (cond) ? ptr->field : def)
102 #define IF_SET2(cond, ptr, field, val) (if(ptr && (cond)) ptr->field = (val))
103 
104 #if !DEPRECATED_INIT_PACKET
105 template<typename T>
107 {
108  FFWrapperRef() = default;
109  explicit FFWrapperRef(const T &raw)
110  : m_raw(raw) {}
111 
112  const T* raw() const { return &m_raw; }
113  T* raw() { return &m_raw; }
114  void reset(const T &raw = T()) { m_raw = raw; }
115  bool isNull() const {
116  static const T empty = T();
117  auto res = memcmp(&m_raw, &empty, sizeof(empty));
118  return (res != 0);
119  }
120 
121  void _log(int level, const char *fmt) const
122  {
123  av_log(&m_raw, level, fmt);
124  }
125 
126  template<typename... Args>
127  void _log(int level, const char* fmt, const Args&... args) const
128  {
129  av_log(&m_raw, level, fmt, args...);
130  }
131 
132 protected:
133  T m_raw = T();
134 };
135 #endif
136 
137 template<typename WrapperClass, typename T, T NoneValue = static_cast<T>(-1)>
139 {
140  constexpr PixSampleFmtWrapper() = default;
141  constexpr PixSampleFmtWrapper(T fmt) noexcept : m_fmt(fmt) {}
142 
143  // Access to the stored value
144  operator T() const noexcept
145  {
146  return m_fmt;
147  }
148 
149  T get() const noexcept
150  {
151  return m_fmt;
152  }
153 
154  operator T&() noexcept
155  {
156  return m_fmt;
157  }
158 
159  WrapperClass& operator=(T fmt) noexcept
160  {
161  m_fmt = fmt;
162  return *this;
163  }
164 
165  void set(T fmt) noexcept
166  {
167  m_fmt = fmt;
168  }
169 
170  // IO Stream interface
171  friend std::ostream& operator<<(std::ostream& ost, WrapperClass fmt)
172  {
173  ost << fmt.name();
174  return ost;
175  }
176 
177 protected:
178  T m_fmt = NoneValue;
179 };
180 
181 
182 #ifdef __cpp_lib_format
183 # include <format>
184 
185 namespace av {
186 
187 template <typename B>
188 concept has_name_method_with_ec = requires(const B& type, std::error_code ec) {
189  { type.name(ec) } -> std::convertible_to<std::string_view>;
190 };
191 
192 template <typename B>
193 concept has_name_method_without_ec = requires(const B& type) {
194  { type.name() } -> std::convertible_to<std::string_view>;
195 };
196 
197 template <typename B>
198 concept has_long_name_method_with_ec = requires(const B& type, std::error_code ec) {
199  { type.longName(ec) } -> std::convertible_to<std::string_view>;
200 };
201 
202 template <typename B>
203 concept has_long_name_method_without_ec = requires(const B& type) {
204  { type.longName() } -> std::convertible_to<std::string_view>;
205 };
206 } // ::av
207 
208 template <class T, class CharT>
209  requires av::has_name_method_with_ec<T> || av::has_name_method_without_ec<T>
210 struct std::formatter<T, CharT>
211 {
212  bool longName = false;
213 
214  template<typename ParseContext>
215  constexpr ParseContext::iterator parse(ParseContext& ctx)
216  {
217  auto it = ctx.begin();
218  if constexpr (requires { requires av::has_long_name_method_with_ec<T> || av::has_long_name_method_without_ec<T>; }) {
219  if (it == ctx.end())
220  return it;
221  if (*it == 'l') {
222  longName = true;
223  ++it;
224  }
225  if (it != ctx.end() && *it != '}')
226  throw std::format_error("Invalid format args");
227  }
228  return it;
229  }
230 
231  template<typename ParseContext>
232  auto format(const T& value, ParseContext& ctx) const
233  {
234  if (longName) {
235  if constexpr (requires { requires av::has_long_name_method_with_ec<T>; }) {
236  std::error_code dummy;
237  return std::format_to(ctx.out(), "{}", value.longName(dummy));
238  } else if constexpr (requires { requires av::has_long_name_method_without_ec<T>; }) {
239  return std::format_to(ctx.out(), "{}", value.longName());
240  }
241  } else {
242  if constexpr (requires { requires av::has_name_method_with_ec<T>; }) {
243  std::error_code dummy;
244  return std::format_to(ctx.out(), "{}", value.name(dummy));
245  } else {
246  return std::format_to(ctx.out(), "{}", value.name());
247  }
248  }
249  return ctx.out();
250  }
251 };
252 #endif
PixSampleFmtWrapper::set
void set(T fmt) noexcept
Definition: ffmpeg.h:165
PixSampleFmtWrapper
Definition: ffmpeg.h:138
FFWrapperRef::raw
const T * raw() const
Definition: ffmpeg.h:112
FFWrapperPtr::isNull
bool isNull() const
Definition: ffmpeg.h:75
FFWrapperPtr
Definition: ffmpeg.h:66
FFWrapperPtr::FFWrapperPtr
FFWrapperPtr()=default
FFWrapperPtr::FFWrapperPtr
FFWrapperPtr(T *raw)
Definition: ffmpeg.h:69
FFWrapperRef::_log
void _log(int level, const char *fmt, const Args &... args) const
Definition: ffmpeg.h:127
FFWrapperRef::isNull
bool isNull() const
Definition: ffmpeg.h:115
FFWrapperRef::FFWrapperRef
FFWrapperRef()=default
FFWrapperRef::m_raw
T m_raw
Definition: ffmpeg.h:133
PixSampleFmtWrapper::PixSampleFmtWrapper
constexpr PixSampleFmtWrapper(T fmt) noexcept
Definition: ffmpeg.h:141
FFWrapperPtr::_log
void _log(int level, const char *fmt) const
Definition: ffmpeg.h:77
FFWrapperRef
Definition: ffmpeg.h:106
FFWrapperRef::reset
void reset(const T &raw=T())
Definition: ffmpeg.h:114
PixSampleFmtWrapper::m_fmt
T m_fmt
Definition: ffmpeg.h:178
PixSampleFmtWrapper::operator<<
friend std::ostream & operator<<(std::ostream &ost, WrapperClass fmt)
Definition: ffmpeg.h:171
FFWrapperPtr::raw
const T * raw() const
Definition: ffmpeg.h:72
av
Definition: audioresampler.cpp:8
FFWrapperPtr::raw
T * raw()
Definition: ffmpeg.h:73
PixSampleFmtWrapper::PixSampleFmtWrapper
constexpr PixSampleFmtWrapper()=default
FFWrapperPtr::m_raw
T * m_raw
Definition: ffmpeg.h:89
FFWrapperRef::raw
T * raw()
Definition: ffmpeg.h:113
FFWrapperPtr::reset
void reset(T *raw=nullptr)
Definition: ffmpeg.h:74
FFWrapperPtr::_log
void _log(int level, const char *fmt, const Args &... args) const
Definition: ffmpeg.h:83
PixSampleFmtWrapper::operator=
WrapperClass & operator=(T fmt) noexcept
Definition: ffmpeg.h:159
PixSampleFmtWrapper::get
T get() const noexcept
Definition: ffmpeg.h:149
FFWrapperRef::FFWrapperRef
FFWrapperRef(const T &raw)
Definition: ffmpeg.h:109
FFWrapperRef::_log
void _log(int level, const char *fmt) const
Definition: ffmpeg.h:121