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)
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, format code %s\n",
218  width, height, tb_num, tb_den, field_order, direction, 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  || target_mode == bmd_mode) {
252  ctx->bmd_mode = bmd_mode;
253  ctx->bmd_width = bmd_width;
254  ctx->bmd_height = bmd_height;
255  ctx->bmd_tb_den = bmd_tb_den;
256  ctx->bmd_tb_num = bmd_tb_num;
257  ctx->bmd_field_dominance = bmd_field_dominance;
258  av_log(avctx, AV_LOG_INFO, "Found Decklink mode %d x %d with rate %.2f%s\n",
259  bmd_width, bmd_height, 1/av_q2d(mode_tb),
260  (ctx->bmd_field_dominance==bmdLowerFieldFirst || ctx->bmd_field_dominance==bmdUpperFieldFirst)?"(i)":"");
261  }
262 
263  mode->Release();
264  i++;
265  }
266 
267  itermode->Release();
268 
269  if (ctx->bmd_mode == bmdModeUnknown)
270  return -1;
271 
272 #if BLACKMAGIC_DECKLINK_API_VERSION >= 0x0b000000
273  if (direction == DIRECTION_IN) {
274  if (ctx->dli->DoesSupportVideoMode(ctx->video_input, ctx->bmd_mode, (BMDPixelFormat) cctx->raw_format,
275  bmdSupportedVideoModeDefault,
276  &support) != S_OK)
277  return -1;
278  } else {
279  BMDDisplayMode actualMode = ctx->bmd_mode;
280  if (ctx->dlo->DoesSupportVideoMode(bmdVideoConnectionUnspecified, ctx->bmd_mode, ctx->raw_format,
281  bmdSupportedVideoModeDefault,
282  &actualMode, &support) != S_OK || !support || ctx->bmd_mode != actualMode) {
283  return -1;
284  }
285 
286  }
287  if (support)
288  return 0;
289 #else
290  if (direction == DIRECTION_IN) {
291  if (ctx->dli->DoesSupportVideoMode(ctx->bmd_mode, (BMDPixelFormat) cctx->raw_format,
292  bmdVideoOutputFlagDefault,
293  &support, NULL) != S_OK)
294  return -1;
295  } else {
296  if (!ctx->supports_vanc || ctx->dlo->DoesSupportVideoMode(ctx->bmd_mode, ctx->raw_format,
297  bmdVideoOutputVANC,
298  &support, NULL) != S_OK || support != bmdDisplayModeSupported) {
299  /* Try without VANC enabled */
300  if (ctx->dlo->DoesSupportVideoMode(ctx->bmd_mode, ctx->raw_format,
301  bmdVideoOutputFlagDefault,
302  &support, NULL) != S_OK) {
303  return -1;
304  }
305  ctx->supports_vanc = 0;
306  }
307 
308  }
309  if (support == bmdDisplayModeSupported)
310  return 0;
311 #endif
312 
313  return -1;
314 }
315 
317  return ff_decklink_set_format(avctx, 0, 0, 0, 0, AV_FIELD_UNKNOWN, direction);
318 }
319 
321  struct AVDeviceInfoList *device_list,
322  int show_inputs, int show_outputs)
323 {
324  IDeckLink *dl = NULL;
325  IDeckLinkIterator *iter = decklink_create_iterator(avctx);
326  int ret = 0;
327 
328  if (!iter)
329  return AVERROR(EIO);
330 
331  while (ret == 0 && iter->Next(&dl) == S_OK) {
332  IDeckLinkOutput *output_config;
333  IDeckLinkInput *input_config;
334  const char *display_name = NULL;
335  const char *unique_name = NULL;
336  AVDeviceInfo *new_device = NULL;
337  int add = 0;
338 
339  ret = decklink_get_attr_string(dl, BMDDeckLinkDisplayName, &display_name);
340  if (ret < 0)
341  goto next;
342  ret = decklink_get_attr_string(dl, BMDDeckLinkDeviceHandle, &unique_name);
343  if (ret < 0)
344  goto next;
345 
346  if (show_outputs) {
347  if (dl->QueryInterface(IID_IDeckLinkOutput, (void **)&output_config) == S_OK) {
348  output_config->Release();
349  add = 1;
350  }
351  }
352 
353  if (show_inputs) {
354  if (dl->QueryInterface(IID_IDeckLinkInput, (void **)&input_config) == S_OK) {
355  input_config->Release();
356  add = 1;
357  }
358  }
359 
360  if (add == 1) {
361  new_device = (AVDeviceInfo *) av_mallocz(sizeof(AVDeviceInfo));
362  if (!new_device) {
363  ret = AVERROR(ENOMEM);
364  goto next;
365  }
366 
367  new_device->device_name = av_strdup(unique_name ? unique_name : display_name);
368  new_device->device_description = av_strdup(display_name);
369 
370  if (!new_device->device_name ||
371  !new_device->device_description ||
372  av_dynarray_add_nofree(&device_list->devices, &device_list->nb_devices, new_device) < 0) {
373  ret = AVERROR(ENOMEM);
374  av_freep(&new_device->device_name);
375  av_freep(&new_device->device_description);
376  av_freep(&new_device);
377  goto next;
378  }
379  }
380 
381  next:
382  av_freep(&display_name);
383  av_freep(&unique_name);
384  dl->Release();
385  }
386  iter->Release();
387  return ret;
388 }
389 
390 /* This is a wrapper around the ff_decklink_list_devices() which dumps the
391  output to av_log() and exits (for backward compatibility with the
392  "-list_devices" argument). */
394  int show_inputs, int show_outputs)
395 {
396  struct AVDeviceInfoList *device_list = NULL;
397  int ret;
398 
399  device_list = (struct AVDeviceInfoList *) av_mallocz(sizeof(AVDeviceInfoList));
400  if (!device_list)
401  return;
402 
403  ret = ff_decklink_list_devices(avctx, device_list, show_inputs, show_outputs);
404  if (ret == 0) {
405  av_log(avctx, AV_LOG_INFO, "Blackmagic DeckLink %s devices:\n",
406  show_inputs ? "input" : "output");
407  for (int i = 0; i < device_list->nb_devices; i++) {
408  av_log(avctx, AV_LOG_INFO, "\t'%s'\n", device_list->devices[i]->device_description);
409  }
410  }
411  avdevice_free_list_devices(&device_list);
412 }
413 
415 {
416  struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
417  struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
418  IDeckLinkDisplayModeIterator *itermode;
419  IDeckLinkDisplayMode *mode;
420  uint32_t format_code;
421  HRESULT res;
422 
423  if (direction == DIRECTION_IN) {
424  int ret;
425  ret = decklink_select_input(avctx, bmdDeckLinkConfigAudioInputConnection);
426  if (ret < 0)
427  return ret;
428  ret = decklink_select_input(avctx, bmdDeckLinkConfigVideoInputConnection);
429  if (ret < 0)
430  return ret;
431  res = ctx->dli->GetDisplayModeIterator (&itermode);
432  } else {
433  res = ctx->dlo->GetDisplayModeIterator (&itermode);
434  }
435 
436  if (res!= S_OK) {
437  av_log(avctx, AV_LOG_ERROR, "Could not get Display Mode Iterator\n");
438  return AVERROR(EIO);
439  }
440 
441  av_log(avctx, AV_LOG_INFO, "Supported formats for '%s':\n\tformat_code\tdescription",
442  avctx->url);
443  while (itermode->Next(&mode) == S_OK) {
444  BMDTimeValue tb_num, tb_den;
445  mode->GetFrameRate(&tb_num, &tb_den);
446  format_code = av_bswap32(mode->GetDisplayMode());
447  av_log(avctx, AV_LOG_INFO, "\n\t%.4s\t\t%ldx%ld at %d/%d fps",
448  (char*) &format_code, mode->GetWidth(), mode->GetHeight(),
449  (int) tb_den, (int) tb_num);
450  switch (mode->GetFieldDominance()) {
451  case bmdLowerFieldFirst:
452  av_log(avctx, AV_LOG_INFO, " (interlaced, lower field first)"); break;
453  case bmdUpperFieldFirst:
454  av_log(avctx, AV_LOG_INFO, " (interlaced, upper field first)"); break;
455  }
456  mode->Release();
457  }
458  av_log(avctx, AV_LOG_INFO, "\n");
459 
460  itermode->Release();
461 
462  return 0;
463 }
464 
466 {
467  struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
468  struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
469 
470  if (ctx->dli)
471  ctx->dli->Release();
472  if (ctx->dlo)
473  ctx->dlo->Release();
474  if (ctx->attr)
475  ctx->attr->Release();
476  if (ctx->cfg)
477  ctx->cfg->Release();
478  if (ctx->dl)
479  ctx->dl->Release();
480 }
481 
483 {
484  struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
485  struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
486  IDeckLink *dl = NULL;
487  IDeckLinkIterator *iter = decklink_create_iterator(avctx);
488  if (!iter)
489  return AVERROR_EXTERNAL;
490 
491  while (iter->Next(&dl) == S_OK) {
492  const char *display_name = NULL;
493  const char *unique_name = NULL;
494  decklink_get_attr_string(dl, BMDDeckLinkDisplayName, &display_name);
495  decklink_get_attr_string(dl, BMDDeckLinkDeviceHandle, &unique_name);
496  if (display_name && !strcmp(name, display_name) || unique_name && !strcmp(name, unique_name)) {
497  av_free((void *)unique_name);
498  av_free((void *)display_name);
499  ctx->dl = dl;
500  break;
501  }
502  av_free((void *)display_name);
503  av_free((void *)unique_name);
504  dl->Release();
505  }
506  iter->Release();
507  if (!ctx->dl)
508  return AVERROR(ENXIO);
509 
510  if (ctx->dl->QueryInterface(IID_IDeckLinkConfiguration, (void **)&ctx->cfg) != S_OK) {
511  av_log(avctx, AV_LOG_ERROR, "Could not get configuration interface for '%s'\n", name);
512  ff_decklink_cleanup(avctx);
513  return AVERROR_EXTERNAL;
514  }
515 
516  if (ctx->dl->QueryInterface(IID_IDeckLinkProfileAttributes, (void **)&ctx->attr) != S_OK) {
517  av_log(avctx, AV_LOG_ERROR, "Could not get attributes interface for '%s'\n", name);
518  ff_decklink_cleanup(avctx);
519  return AVERROR_EXTERNAL;
520  }
521 
522  return 0;
523 }
#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:1357
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:1453
#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:1563
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:1385
#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