FFmpeg
decklink_common.cpp
Go to the documentation of this file.
1 /*
2  * Blackmagic DeckLink output
3  * Copyright (c) 2013-2014 Ramiro Polla, Luca Barbato, Deti Fliegl
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /* Include internal.h first to avoid conflict between winsock.h (used by
23  * DeckLink headers) and winsock2.h (used by libavformat) in MSVC++ builds */
24 extern "C" {
25 #include "libavformat/internal.h"
26 }
27 
28 #include <DeckLinkAPI.h>
29 #ifdef _WIN32
30 #include <DeckLinkAPI_i.c>
31 #else
32 /* The file provided by the SDK is known to be missing prototypes, which doesn't
33  cause issues with GCC since the warning doesn't apply to C++ files. However
34  Clang does complain (and warnings are treated as errors), so suppress the
35  warning just for this one file */
36 #ifdef __clang__
37 #pragma clang diagnostic push
38 #pragma clang diagnostic ignored "-Wmissing-prototypes"
39 #endif
40 #include <DeckLinkAPIDispatch.cpp>
41 #ifdef __clang__
42 #pragma clang diagnostic pop
43 #endif
44 #endif
45 
46 extern "C" {
47 #include "libavformat/avformat.h"
48 #include "libavutil/imgutils.h"
49 #include "libavutil/intreadwrite.h"
50 #include "libavutil/bswap.h"
51 #include "avdevice.h"
52 }
53 
54 #include "decklink_common.h"
55 
56 static IDeckLinkIterator *decklink_create_iterator(AVFormatContext *avctx)
57 {
58  IDeckLinkIterator *iter;
59 
60 #ifdef _WIN32
61  if (CoInitialize(NULL) < 0) {
62  av_log(avctx, AV_LOG_ERROR, "COM initialization failed.\n");
63  return NULL;
64  }
65 
66  if (CoCreateInstance(CLSID_CDeckLinkIterator, NULL, CLSCTX_ALL,
67  IID_IDeckLinkIterator, (void**) &iter) != S_OK) {
68  iter = NULL;
69  }
70 #else
71  iter = CreateDeckLinkIteratorInstance();
72 #endif
73  if (!iter)
74  av_log(avctx, AV_LOG_ERROR, "Could not create DeckLink iterator. "
75  "Make sure you have DeckLink drivers " BLACKMAGIC_DECKLINK_API_VERSION_STRING " or newer installed.\n");
76 
77  return iter;
78 }
79 
80 static int decklink_get_attr_string(IDeckLink *dl, BMDDeckLinkAttributeID cfg_id, const char **s)
81 {
83  HRESULT hr;
85  *s = NULL;
86  if (dl->QueryInterface(IID_IDeckLinkProfileAttributes, (void **)&attr) != S_OK)
87  return AVERROR_EXTERNAL;
88  hr = attr->GetString(cfg_id, &tmp);
89  attr->Release();
90  if (hr == S_OK) {
91  *s = DECKLINK_STRDUP(tmp);
92  DECKLINK_FREE(tmp);
93  if (!*s)
94  return AVERROR(ENOMEM);
95  } else if (hr == E_FAIL) {
96  return AVERROR_EXTERNAL;
97  }
98  return 0;
99 }
100 
101 static int decklink_select_input(AVFormatContext *avctx, BMDDeckLinkConfigurationID cfg_id)
102 {
103  struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
104  struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
105  BMDDeckLinkAttributeID attr_id = (cfg_id == bmdDeckLinkConfigAudioInputConnection) ? BMDDeckLinkAudioInputConnections : BMDDeckLinkVideoInputConnections;
106  int64_t bmd_input = (cfg_id == bmdDeckLinkConfigAudioInputConnection) ? (int64_t)ctx->audio_input : (int64_t)ctx->video_input;
107  const char *type_name = (cfg_id == bmdDeckLinkConfigAudioInputConnection) ? "audio" : "video";
108  int64_t supported_connections = 0;
109  HRESULT res;
110 
111  if (bmd_input) {
112  res = ctx->attr->GetInt(attr_id, &supported_connections);
113  if (res != S_OK) {
114  av_log(avctx, AV_LOG_ERROR, "Failed to query supported %s inputs.\n", type_name);
115  return AVERROR_EXTERNAL;
116  }
117  if ((supported_connections & bmd_input) != bmd_input) {
118  av_log(avctx, AV_LOG_ERROR, "Device does not support selected %s input.\n", type_name);
119  return AVERROR(ENOSYS);
120  }
121  res = ctx->cfg->SetInt(cfg_id, bmd_input);
122  if (res != S_OK) {
123  av_log(avctx, AV_LOG_ERROR, "Failed to select %s input.\n", type_name);
124  return AVERROR_EXTERNAL;
125  }
126  }
127  return 0;
128 }
129 
130 static DECKLINK_BOOL field_order_eq(enum AVFieldOrder field_order, BMDFieldDominance bmd_field_order)
131 {
132  if (field_order == AV_FIELD_UNKNOWN)
133  return true;
134  if ((field_order == AV_FIELD_TT || field_order == AV_FIELD_TB) && bmd_field_order == bmdUpperFieldFirst)
135  return true;
136  if ((field_order == AV_FIELD_BB || field_order == AV_FIELD_BT) && bmd_field_order == bmdLowerFieldFirst)
137  return true;
138  if (field_order == AV_FIELD_PROGRESSIVE && (bmd_field_order == bmdProgressiveFrame || bmd_field_order == bmdProgressiveSegmentedFrame))
139  return true;
140  return false;
141 }
142 
144  decklink_direction_t direction) {
145  struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
146  struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
147  HRESULT res;
148 
149  if (ctx->duplex_mode) {
150  DECKLINK_BOOL duplex_supported = false;
151 
152 #if BLACKMAGIC_DECKLINK_API_VERSION >= 0x0b000000
153  IDeckLinkProfileManager *manager = NULL;
154  if (ctx->dl->QueryInterface(IID_IDeckLinkProfileManager, (void **)&manager) == S_OK)
155  duplex_supported = true;
156 #else
157  if (ctx->attr->GetFlag(BMDDeckLinkSupportsDuplexModeConfiguration, &duplex_supported) != S_OK)
158  duplex_supported = false;
159 #endif
160 
161  if (duplex_supported) {
162 #if BLACKMAGIC_DECKLINK_API_VERSION >= 0x0b000000
163  IDeckLinkProfile *profile = NULL;
164  BMDProfileID bmd_profile_id = ctx->duplex_mode == 2 ? bmdProfileOneSubDeviceFullDuplex : bmdProfileTwoSubDevicesHalfDuplex;
165  res = manager->GetProfile(bmd_profile_id, &profile);
166  if (res == S_OK) {
167  res = profile->SetActive();
168  profile->Release();
169  }
170  manager->Release();
171 #else
172  res = ctx->cfg->SetInt(bmdDeckLinkConfigDuplexMode, ctx->duplex_mode == 2 ? bmdDuplexModeFull : bmdDuplexModeHalf);
173 #endif
174  if (res != S_OK)
175  av_log(avctx, AV_LOG_WARNING, "Setting duplex mode failed.\n");
176  else
177  av_log(avctx, AV_LOG_VERBOSE, "Successfully set duplex mode to %s duplex.\n", ctx->duplex_mode == 2 ? "full" : "half");
178  } else {
179  av_log(avctx, AV_LOG_WARNING, "Unable to set duplex mode, because it is not supported.\n");
180  }
181  }
182  if (direction == DIRECTION_IN) {
183  int ret;
184  ret = decklink_select_input(avctx, bmdDeckLinkConfigAudioInputConnection);
185  if (ret < 0)
186  return ret;
187  ret = decklink_select_input(avctx, bmdDeckLinkConfigVideoInputConnection);
188  if (ret < 0)
189  return ret;
190  }
191  if (direction == DIRECTION_OUT && cctx->timing_offset != INT_MIN) {
192  res = ctx->cfg->SetInt(bmdDeckLinkConfigReferenceInputTimingOffset, cctx->timing_offset);
193  if (res != S_OK)
194  av_log(avctx, AV_LOG_WARNING, "Setting timing offset failed.\n");
195  }
196  return 0;
197 }
198 
200  int width, int height,
201  int tb_num, int tb_den,
202  enum AVFieldOrder field_order,
203  decklink_direction_t direction, int num)
204 {
205  struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
206  struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
207 #if BLACKMAGIC_DECKLINK_API_VERSION >= 0x0b000000
208  DECKLINK_BOOL support;
209 #else
210  BMDDisplayModeSupport support;
211 #endif
212  IDeckLinkDisplayModeIterator *itermode;
213  IDeckLinkDisplayMode *mode;
214  int i = 1;
215  HRESULT res;
216 
217  av_log(avctx, AV_LOG_DEBUG, "Trying to find mode for frame size %dx%d, frame timing %d/%d, field order %d, direction %d, mode number %d, format code %s\n",
218  width, height, tb_num, tb_den, field_order, direction, num, (cctx->format_code) ? cctx->format_code : "(unset)");
219 
220  if (direction == DIRECTION_IN) {
221  res = ctx->dli->GetDisplayModeIterator (&itermode);
222  } else {
223  res = ctx->dlo->GetDisplayModeIterator (&itermode);
224  }
225 
226  if (res!= S_OK) {
227  av_log(avctx, AV_LOG_ERROR, "Could not get Display Mode Iterator\n");
228  return AVERROR(EIO);
229  }
230 
231  char format_buf[] = " ";
232  if (cctx->format_code)
233  memcpy(format_buf, cctx->format_code, FFMIN(strlen(cctx->format_code), sizeof(format_buf)));
234  BMDDisplayMode target_mode = (BMDDisplayMode)AV_RB32(format_buf);
235  AVRational target_tb = av_make_q(tb_num, tb_den);
236  ctx->bmd_mode = bmdModeUnknown;
237  while ((ctx->bmd_mode == bmdModeUnknown) && itermode->Next(&mode) == S_OK) {
238  BMDTimeValue bmd_tb_num, bmd_tb_den;
239  int bmd_width = mode->GetWidth();
240  int bmd_height = mode->GetHeight();
241  BMDDisplayMode bmd_mode = mode->GetDisplayMode();
242  BMDFieldDominance bmd_field_dominance = mode->GetFieldDominance();
243 
244  mode->GetFrameRate(&bmd_tb_num, &bmd_tb_den);
245  AVRational mode_tb = av_make_q(bmd_tb_num, bmd_tb_den);
246 
247  if ((bmd_width == width &&
248  bmd_height == height &&
249  !av_cmp_q(mode_tb, target_tb) &&
250  field_order_eq(field_order, bmd_field_dominance))
251  || i == num
252  || target_mode == bmd_mode) {
253  ctx->bmd_mode = bmd_mode;
254  ctx->bmd_width = bmd_width;
255  ctx->bmd_height = bmd_height;
256  ctx->bmd_tb_den = bmd_tb_den;
257  ctx->bmd_tb_num = bmd_tb_num;
258  ctx->bmd_field_dominance = bmd_field_dominance;
259  av_log(avctx, AV_LOG_INFO, "Found Decklink mode %d x %d with rate %.2f%s\n",
260  bmd_width, bmd_height, 1/av_q2d(mode_tb),
261  (ctx->bmd_field_dominance==bmdLowerFieldFirst || ctx->bmd_field_dominance==bmdUpperFieldFirst)?"(i)":"");
262  }
263 
264  mode->Release();
265  i++;
266  }
267 
268  itermode->Release();
269 
270  if (ctx->bmd_mode == bmdModeUnknown)
271  return -1;
272 
273 #if BLACKMAGIC_DECKLINK_API_VERSION >= 0x0b000000
274  if (direction == DIRECTION_IN) {
275  if (ctx->dli->DoesSupportVideoMode(ctx->video_input, ctx->bmd_mode, (BMDPixelFormat) cctx->raw_format,
276  bmdSupportedVideoModeDefault,
277  &support) != S_OK)
278  return -1;
279  } else {
280  BMDDisplayMode actualMode = ctx->bmd_mode;
281  if (ctx->dlo->DoesSupportVideoMode(bmdVideoConnectionUnspecified, ctx->bmd_mode, ctx->raw_format,
282  bmdSupportedVideoModeDefault,
283  &actualMode, &support) != S_OK || !support || ctx->bmd_mode != actualMode) {
284  return -1;
285  }
286 
287  }
288  if (support)
289  return 0;
290 #else
291  if (direction == DIRECTION_IN) {
292  if (ctx->dli->DoesSupportVideoMode(ctx->bmd_mode, (BMDPixelFormat) cctx->raw_format,
293  bmdVideoOutputFlagDefault,
294  &support, NULL) != S_OK)
295  return -1;
296  } else {
297  if (!ctx->supports_vanc || ctx->dlo->DoesSupportVideoMode(ctx->bmd_mode, ctx->raw_format,
298  bmdVideoOutputVANC,
299  &support, NULL) != S_OK || support != bmdDisplayModeSupported) {
300  /* Try without VANC enabled */
301  if (ctx->dlo->DoesSupportVideoMode(ctx->bmd_mode, ctx->raw_format,
302  bmdVideoOutputFlagDefault,
303  &support, NULL) != S_OK) {
304  return -1;
305  }
306  ctx->supports_vanc = 0;
307  }
308 
309  }
310  if (support == bmdDisplayModeSupported)
311  return 0;
312 #endif
313 
314  return -1;
315 }
316 
318  return ff_decklink_set_format(avctx, 0, 0, 0, 0, AV_FIELD_UNKNOWN, direction, num);
319 }
320 
322  struct AVDeviceInfoList *device_list,
323  int show_inputs, int show_outputs)
324 {
325  IDeckLink *dl = NULL;
326  IDeckLinkIterator *iter = decklink_create_iterator(avctx);
327  int ret = 0;
328 
329  if (!iter)
330  return AVERROR(EIO);
331 
332  while (ret == 0 && iter->Next(&dl) == S_OK) {
333  IDeckLinkOutput *output_config;
334  IDeckLinkInput *input_config;
335  const char *display_name = NULL;
336  const char *unique_name = NULL;
337  AVDeviceInfo *new_device = NULL;
338  int add = 0;
339 
340  ret = decklink_get_attr_string(dl, BMDDeckLinkDisplayName, &display_name);
341  if (ret < 0)
342  goto next;
343  ret = decklink_get_attr_string(dl, BMDDeckLinkDeviceHandle, &unique_name);
344  if (ret < 0)
345  goto next;
346 
347  if (show_outputs) {
348  if (dl->QueryInterface(IID_IDeckLinkOutput, (void **)&output_config) == S_OK) {
349  output_config->Release();
350  add = 1;
351  }
352  }
353 
354  if (show_inputs) {
355  if (dl->QueryInterface(IID_IDeckLinkInput, (void **)&input_config) == S_OK) {
356  input_config->Release();
357  add = 1;
358  }
359  }
360 
361  if (add == 1) {
362  new_device = (AVDeviceInfo *) av_mallocz(sizeof(AVDeviceInfo));
363  if (!new_device) {
364  ret = AVERROR(ENOMEM);
365  goto next;
366  }
367 
368  new_device->device_name = av_strdup(unique_name ? unique_name : display_name);
369  new_device->device_description = av_strdup(display_name);
370 
371  if (!new_device->device_name ||
372  !new_device->device_description ||
373  av_dynarray_add_nofree(&device_list->devices, &device_list->nb_devices, new_device) < 0) {
374  ret = AVERROR(ENOMEM);
375  av_freep(&new_device->device_name);
376  av_freep(&new_device->device_description);
377  av_freep(&new_device);
378  goto next;
379  }
380  }
381 
382  next:
383  av_freep(&display_name);
384  av_freep(&unique_name);
385  dl->Release();
386  }
387  iter->Release();
388  return ret;
389 }
390 
391 /* This is a wrapper around the ff_decklink_list_devices() which dumps the
392  output to av_log() and exits (for backward compatibility with the
393  "-list_devices" argument). */
395  int show_inputs, int show_outputs)
396 {
397  struct AVDeviceInfoList *device_list = NULL;
398  int ret;
399 
400  device_list = (struct AVDeviceInfoList *) av_mallocz(sizeof(AVDeviceInfoList));
401  if (!device_list)
402  return;
403 
404  ret = ff_decklink_list_devices(avctx, device_list, show_inputs, show_outputs);
405  if (ret == 0) {
406  av_log(avctx, AV_LOG_INFO, "Blackmagic DeckLink %s devices:\n",
407  show_inputs ? "input" : "output");
408  for (int i = 0; i < device_list->nb_devices; i++) {
409  av_log(avctx, AV_LOG_INFO, "\t'%s'\n", device_list->devices[i]->device_description);
410  }
411  }
412  avdevice_free_list_devices(&device_list);
413 }
414 
416 {
417  struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
418  struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
419  IDeckLinkDisplayModeIterator *itermode;
420  IDeckLinkDisplayMode *mode;
421  uint32_t format_code;
422  HRESULT res;
423 
424  if (direction == DIRECTION_IN) {
425  int ret;
426  ret = decklink_select_input(avctx, bmdDeckLinkConfigAudioInputConnection);
427  if (ret < 0)
428  return ret;
429  ret = decklink_select_input(avctx, bmdDeckLinkConfigVideoInputConnection);
430  if (ret < 0)
431  return ret;
432  res = ctx->dli->GetDisplayModeIterator (&itermode);
433  } else {
434  res = ctx->dlo->GetDisplayModeIterator (&itermode);
435  }
436 
437  if (res!= S_OK) {
438  av_log(avctx, AV_LOG_ERROR, "Could not get Display Mode Iterator\n");
439  return AVERROR(EIO);
440  }
441 
442  av_log(avctx, AV_LOG_INFO, "Supported formats for '%s':\n\tformat_code\tdescription",
443  avctx->url);
444  while (itermode->Next(&mode) == S_OK) {
445  BMDTimeValue tb_num, tb_den;
446  mode->GetFrameRate(&tb_num, &tb_den);
447  format_code = av_bswap32(mode->GetDisplayMode());
448  av_log(avctx, AV_LOG_INFO, "\n\t%.4s\t\t%ldx%ld at %d/%d fps",
449  (char*) &format_code, mode->GetWidth(), mode->GetHeight(),
450  (int) tb_den, (int) tb_num);
451  switch (mode->GetFieldDominance()) {
452  case bmdLowerFieldFirst:
453  av_log(avctx, AV_LOG_INFO, " (interlaced, lower field first)"); break;
454  case bmdUpperFieldFirst:
455  av_log(avctx, AV_LOG_INFO, " (interlaced, upper field first)"); break;
456  }
457  mode->Release();
458  }
459  av_log(avctx, AV_LOG_INFO, "\n");
460 
461  itermode->Release();
462 
463  return 0;
464 }
465 
467 {
468  struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
469  struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
470 
471  if (ctx->dli)
472  ctx->dli->Release();
473  if (ctx->dlo)
474  ctx->dlo->Release();
475  if (ctx->attr)
476  ctx->attr->Release();
477  if (ctx->cfg)
478  ctx->cfg->Release();
479  if (ctx->dl)
480  ctx->dl->Release();
481 }
482 
484 {
485  struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
486  struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
487  IDeckLink *dl = NULL;
488  IDeckLinkIterator *iter = decklink_create_iterator(avctx);
489  if (!iter)
490  return AVERROR_EXTERNAL;
491 
492  while (iter->Next(&dl) == S_OK) {
493  const char *display_name = NULL;
494  const char *unique_name = NULL;
495  decklink_get_attr_string(dl, BMDDeckLinkDisplayName, &display_name);
496  decklink_get_attr_string(dl, BMDDeckLinkDeviceHandle, &unique_name);
497  if (display_name && !strcmp(name, display_name) || unique_name && !strcmp(name, unique_name)) {
498  av_free((void *)unique_name);
499  av_free((void *)display_name);
500  ctx->dl = dl;
501  break;
502  }
503  av_free((void *)display_name);
504  av_free((void *)unique_name);
505  dl->Release();
506  }
507  iter->Release();
508  if (!ctx->dl)
509  return AVERROR(ENXIO);
510 
511  if (ctx->dl->QueryInterface(IID_IDeckLinkConfiguration, (void **)&ctx->cfg) != S_OK) {
512  av_log(avctx, AV_LOG_ERROR, "Could not get configuration interface for '%s'\n", name);
513  ff_decklink_cleanup(avctx);
514  return AVERROR_EXTERNAL;
515  }
516 
517  if (ctx->dl->QueryInterface(IID_IDeckLinkProfileAttributes, (void **)&ctx->attr) != S_OK) {
518  av_log(avctx, AV_LOG_ERROR, "Could not get attributes interface for '%s'\n", name);
519  ff_decklink_cleanup(avctx);
520  return AVERROR_EXTERNAL;
521  }
522 
523  return 0;
524 }
#define NULL
Definition: coverity.c:32
Structure describes basic parameters of the device.
Definition: avdevice.h:452
#define S_OK
Definition: windows2linux.h:40
char * device_description
human friendly name
Definition: avdevice.h:454
misc image utilities
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
char * device_name
device name, format depends on device
Definition: avdevice.h:453
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
Format I/O context.
Definition: avformat.h:1358
void avdevice_free_list_devices(AVDeviceInfoList **device_list)
Convenient function to free result of avdevice_list_devices().
Definition: avdevice.c:250
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:87
#define height
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
int av_dynarray_add_nofree(void *tab_ptr, int *nb_ptr, void *elem)
Add an element to a dynamic array.
Definition: mem.c:294
#define av_log(a,...)
Main libavdevice API header.
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
char * url
input or output URL.
Definition: avformat.h:1454
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
AVDeviceInfo ** devices
list of autodetected devices
Definition: avdevice.h:461
#define FFMIN(a, b)
Definition: common.h:96
#define width
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
#define E_FAIL
Definition: windows2linux.h:44
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
#define av_bswap32
Definition: bswap.h:33
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:251
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition: rational.h:71
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AVFieldOrder
Definition: avcodec.h:1546
byte swapping routines
List of devices.
Definition: avdevice.h:460
mfxU16 profile
Definition: qsvenc.c:44
DWORD HRESULT
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
Main libavformat public API header.
int
#define av_free(p)
void * priv_data
Format private data.
Definition: avformat.h:1386
#define av_freep(p)
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
int nb_devices
number of autodetected devices
Definition: avdevice.h:462
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:57
mode
Use these values in ebur128_init (or&#39;ed).
Definition: ebur128.h:83
const char * name
Definition: opengl_enc.c:102
static uint8_t tmp[11]
Definition: aes_ctr.c:26