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  } else {
77  IDeckLinkAPIInformation *api;
78  int64_t version;
79 #ifdef _WIN32
80  if (CoCreateInstance(CLSID_CDeckLinkAPIInformation, NULL, CLSCTX_ALL,
81  IID_IDeckLinkAPIInformation, (void**) &api) != S_OK) {
82  api = NULL;
83  }
84 #else
85  api = CreateDeckLinkAPIInformationInstance();
86 #endif
87  if (api && api->GetInt(BMDDeckLinkAPIVersion, &version) == S_OK) {
88  if (version < BLACKMAGIC_DECKLINK_API_VERSION)
89  av_log(avctx, AV_LOG_WARNING, "Installed DeckLink drivers are too old and may be incompatible with the SDK this module was built against. "
90  "Make sure you have DeckLink drivers " BLACKMAGIC_DECKLINK_API_VERSION_STRING " or newer installed.\n");
91  } else {
92  av_log(avctx, AV_LOG_ERROR, "Failed to check installed DeckLink API version.\n");
93  }
94  if (api)
95  api->Release();
96  }
97 
98  return iter;
99 }
100 
101 static int decklink_get_attr_string(IDeckLink *dl, BMDDeckLinkAttributeID cfg_id, const char **s)
102 {
104  HRESULT hr;
106  *s = NULL;
107  if (dl->QueryInterface(IID_IDeckLinkProfileAttributes, (void **)&attr) != S_OK)
108  return AVERROR_EXTERNAL;
109  hr = attr->GetString(cfg_id, &tmp);
110  attr->Release();
111  if (hr == S_OK) {
112  *s = DECKLINK_STRDUP(tmp);
113  DECKLINK_FREE(tmp);
114  if (!*s)
115  return AVERROR(ENOMEM);
116  } else if (hr == E_FAIL) {
117  return AVERROR_EXTERNAL;
118  }
119  return 0;
120 }
121 
122 static int decklink_select_input(AVFormatContext *avctx, BMDDeckLinkConfigurationID cfg_id)
123 {
124  struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
125  struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
126  BMDDeckLinkAttributeID attr_id = (cfg_id == bmdDeckLinkConfigAudioInputConnection) ? BMDDeckLinkAudioInputConnections : BMDDeckLinkVideoInputConnections;
127  int64_t bmd_input = (cfg_id == bmdDeckLinkConfigAudioInputConnection) ? (int64_t)ctx->audio_input : (int64_t)ctx->video_input;
128  const char *type_name = (cfg_id == bmdDeckLinkConfigAudioInputConnection) ? "audio" : "video";
129  int64_t supported_connections = 0;
130  HRESULT res;
131 
132  if (bmd_input) {
133  res = ctx->attr->GetInt(attr_id, &supported_connections);
134  if (res != S_OK) {
135  av_log(avctx, AV_LOG_ERROR, "Failed to query supported %s inputs.\n", type_name);
136  return AVERROR_EXTERNAL;
137  }
138  if ((supported_connections & bmd_input) != bmd_input) {
139  av_log(avctx, AV_LOG_ERROR, "Device does not support selected %s input.\n", type_name);
140  return AVERROR(ENOSYS);
141  }
142  res = ctx->cfg->SetInt(cfg_id, bmd_input);
143  if (res != S_OK) {
144  av_log(avctx, AV_LOG_ERROR, "Failed to select %s input.\n", type_name);
145  return AVERROR_EXTERNAL;
146  }
147  }
148  return 0;
149 }
150 
151 static DECKLINK_BOOL field_order_eq(enum AVFieldOrder field_order, BMDFieldDominance bmd_field_order)
152 {
153  if (field_order == AV_FIELD_UNKNOWN)
154  return true;
155  if ((field_order == AV_FIELD_TT || field_order == AV_FIELD_TB) && bmd_field_order == bmdUpperFieldFirst)
156  return true;
157  if ((field_order == AV_FIELD_BB || field_order == AV_FIELD_BT) && bmd_field_order == bmdLowerFieldFirst)
158  return true;
159  if (field_order == AV_FIELD_PROGRESSIVE && (bmd_field_order == bmdProgressiveFrame || bmd_field_order == bmdProgressiveSegmentedFrame))
160  return true;
161  return false;
162 }
163 
165  decklink_direction_t direction) {
166  struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
167  struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
168  HRESULT res;
169 
170  if (ctx->duplex_mode) {
171  DECKLINK_BOOL duplex_supported = false;
172 
173 #if BLACKMAGIC_DECKLINK_API_VERSION >= 0x0b000000
174  IDeckLinkProfileManager *manager = NULL;
175  if (ctx->dl->QueryInterface(IID_IDeckLinkProfileManager, (void **)&manager) == S_OK)
176  duplex_supported = true;
177 #else
178  if (ctx->attr->GetFlag(BMDDeckLinkSupportsDuplexModeConfiguration, &duplex_supported) != S_OK)
179  duplex_supported = false;
180 #endif
181 
182  if (duplex_supported) {
183 #if BLACKMAGIC_DECKLINK_API_VERSION >= 0x0b000000
184  IDeckLinkProfile *profile = NULL;
185  BMDProfileID bmd_profile_id = ctx->duplex_mode == 2 ? bmdProfileOneSubDeviceFullDuplex : bmdProfileTwoSubDevicesHalfDuplex;
186  res = manager->GetProfile(bmd_profile_id, &profile);
187  if (res == S_OK) {
188  res = profile->SetActive();
189  profile->Release();
190  }
191  manager->Release();
192 #else
193  res = ctx->cfg->SetInt(bmdDeckLinkConfigDuplexMode, ctx->duplex_mode == 2 ? bmdDuplexModeFull : bmdDuplexModeHalf);
194 #endif
195  if (res != S_OK)
196  av_log(avctx, AV_LOG_WARNING, "Setting duplex mode failed.\n");
197  else
198  av_log(avctx, AV_LOG_VERBOSE, "Successfully set duplex mode to %s duplex.\n", ctx->duplex_mode == 2 ? "full" : "half");
199  } else {
200  av_log(avctx, AV_LOG_WARNING, "Unable to set duplex mode, because it is not supported.\n");
201  }
202  }
203  if (direction == DIRECTION_IN) {
204  int ret;
205  ret = decklink_select_input(avctx, bmdDeckLinkConfigAudioInputConnection);
206  if (ret < 0)
207  return ret;
208  ret = decklink_select_input(avctx, bmdDeckLinkConfigVideoInputConnection);
209  if (ret < 0)
210  return ret;
211  }
212  if (direction == DIRECTION_OUT && cctx->timing_offset != INT_MIN) {
213  res = ctx->cfg->SetInt(bmdDeckLinkConfigReferenceInputTimingOffset, cctx->timing_offset);
214  if (res != S_OK)
215  av_log(avctx, AV_LOG_WARNING, "Setting timing offset failed.\n");
216  }
217  return 0;
218 }
219 
221  int width, int height,
222  int tb_num, int tb_den,
223  enum AVFieldOrder field_order,
224  decklink_direction_t direction)
225 {
226  struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
227  struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
228 #if BLACKMAGIC_DECKLINK_API_VERSION >= 0x0b000000
229  DECKLINK_BOOL support;
230 #else
231  BMDDisplayModeSupport support;
232 #endif
233  IDeckLinkDisplayModeIterator *itermode;
234  IDeckLinkDisplayMode *mode;
235  int i = 1;
236  HRESULT res;
237 
238  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",
239  width, height, tb_num, tb_den, field_order, direction, cctx->format_code ? cctx->format_code : "(unset)");
240 
241  if (direction == DIRECTION_IN) {
242  res = ctx->dli->GetDisplayModeIterator (&itermode);
243  } else {
244  res = ctx->dlo->GetDisplayModeIterator (&itermode);
245  }
246 
247  if (res!= S_OK) {
248  av_log(avctx, AV_LOG_ERROR, "Could not get Display Mode Iterator\n");
249  return AVERROR(EIO);
250  }
251 
252  char format_buf[] = " ";
253  if (cctx->format_code)
254  memcpy(format_buf, cctx->format_code, FFMIN(strlen(cctx->format_code), sizeof(format_buf)));
255  BMDDisplayMode target_mode = (BMDDisplayMode)AV_RB32(format_buf);
256  AVRational target_tb = av_make_q(tb_num, tb_den);
257  ctx->bmd_mode = bmdModeUnknown;
258  while ((ctx->bmd_mode == bmdModeUnknown) && itermode->Next(&mode) == S_OK) {
259  BMDTimeValue bmd_tb_num, bmd_tb_den;
260  int bmd_width = mode->GetWidth();
261  int bmd_height = mode->GetHeight();
262  BMDDisplayMode bmd_mode = mode->GetDisplayMode();
263  BMDFieldDominance bmd_field_dominance = mode->GetFieldDominance();
264 
265  mode->GetFrameRate(&bmd_tb_num, &bmd_tb_den);
266  AVRational mode_tb = av_make_q(bmd_tb_num, bmd_tb_den);
267 
268  if ((bmd_width == width &&
269  bmd_height == height &&
270  !av_cmp_q(mode_tb, target_tb) &&
271  field_order_eq(field_order, bmd_field_dominance))
272  || target_mode == bmd_mode) {
273  ctx->bmd_mode = bmd_mode;
274  ctx->bmd_width = bmd_width;
275  ctx->bmd_height = bmd_height;
276  ctx->bmd_tb_den = bmd_tb_den;
277  ctx->bmd_tb_num = bmd_tb_num;
278  ctx->bmd_field_dominance = bmd_field_dominance;
279  av_log(avctx, AV_LOG_INFO, "Found Decklink mode %d x %d with rate %.2f%s\n",
280  bmd_width, bmd_height, 1/av_q2d(mode_tb),
281  (ctx->bmd_field_dominance==bmdLowerFieldFirst || ctx->bmd_field_dominance==bmdUpperFieldFirst)?"(i)":"");
282  }
283 
284  mode->Release();
285  i++;
286  }
287 
288  itermode->Release();
289 
290  if (ctx->bmd_mode == bmdModeUnknown)
291  return -1;
292 
293 #if BLACKMAGIC_DECKLINK_API_VERSION >= 0x0b050000
294  if (direction == DIRECTION_IN) {
295  BMDDisplayMode actualMode = ctx->bmd_mode;
296  if (ctx->dli->DoesSupportVideoMode(ctx->video_input, ctx->bmd_mode, ctx->raw_format,
297  bmdNoVideoInputConversion, bmdSupportedVideoModeDefault,
298  &actualMode, &support) != S_OK || !support || ctx->bmd_mode != actualMode)
299  return -1;
300  } else {
301  BMDDisplayMode actualMode = ctx->bmd_mode;
302  if (ctx->dlo->DoesSupportVideoMode(bmdVideoConnectionUnspecified, ctx->bmd_mode, ctx->raw_format,
303  bmdNoVideoOutputConversion, bmdSupportedVideoModeDefault,
304  &actualMode, &support) != S_OK || !support || ctx->bmd_mode != actualMode)
305  return -1;
306  }
307  return 0;
308 #elif BLACKMAGIC_DECKLINK_API_VERSION >= 0x0b000000
309  if (direction == DIRECTION_IN) {
310  if (ctx->dli->DoesSupportVideoMode(ctx->video_input, ctx->bmd_mode, ctx->raw_format,
311  bmdSupportedVideoModeDefault,
312  &support) != S_OK)
313  return -1;
314  } else {
315  BMDDisplayMode actualMode = ctx->bmd_mode;
316  if (ctx->dlo->DoesSupportVideoMode(bmdVideoConnectionUnspecified, ctx->bmd_mode, ctx->raw_format,
317  bmdSupportedVideoModeDefault,
318  &actualMode, &support) != S_OK || !support || ctx->bmd_mode != actualMode) {
319  return -1;
320  }
321 
322  }
323  if (support)
324  return 0;
325 #else
326  if (direction == DIRECTION_IN) {
327  if (ctx->dli->DoesSupportVideoMode(ctx->bmd_mode, ctx->raw_format,
328  bmdVideoOutputFlagDefault,
329  &support, NULL) != S_OK)
330  return -1;
331  } else {
332  if (!ctx->supports_vanc || ctx->dlo->DoesSupportVideoMode(ctx->bmd_mode, ctx->raw_format,
333  bmdVideoOutputVANC,
334  &support, NULL) != S_OK || support != bmdDisplayModeSupported) {
335  /* Try without VANC enabled */
336  if (ctx->dlo->DoesSupportVideoMode(ctx->bmd_mode, ctx->raw_format,
337  bmdVideoOutputFlagDefault,
338  &support, NULL) != S_OK) {
339  return -1;
340  }
341  ctx->supports_vanc = 0;
342  }
343 
344  }
345  if (support == bmdDisplayModeSupported)
346  return 0;
347 #endif
348 
349  return -1;
350 }
351 
353  return ff_decklink_set_format(avctx, 0, 0, 0, 0, AV_FIELD_UNKNOWN, direction);
354 }
355 
357  struct AVDeviceInfoList *device_list,
358  int show_inputs, int show_outputs)
359 {
360  IDeckLink *dl = NULL;
361  IDeckLinkIterator *iter = decklink_create_iterator(avctx);
362  int ret = 0;
363 
364  if (!iter)
365  return AVERROR(EIO);
366 
367  while (ret == 0 && iter->Next(&dl) == S_OK) {
368  IDeckLinkOutput *output_config;
369  IDeckLinkInput *input_config;
370  const char *display_name = NULL;
371  const char *unique_name = NULL;
372  AVDeviceInfo *new_device = NULL;
373  int add = 0;
374 
375  ret = decklink_get_attr_string(dl, BMDDeckLinkDisplayName, &display_name);
376  if (ret < 0)
377  goto next;
378  ret = decklink_get_attr_string(dl, BMDDeckLinkDeviceHandle, &unique_name);
379  if (ret < 0)
380  goto next;
381 
382  if (show_outputs) {
383  if (dl->QueryInterface(IID_IDeckLinkOutput, (void **)&output_config) == S_OK) {
384  output_config->Release();
385  add = 1;
386  }
387  }
388 
389  if (show_inputs) {
390  if (dl->QueryInterface(IID_IDeckLinkInput, (void **)&input_config) == S_OK) {
391  input_config->Release();
392  add = 1;
393  }
394  }
395 
396  if (add == 1) {
397  new_device = (AVDeviceInfo *) av_mallocz(sizeof(AVDeviceInfo));
398  if (!new_device) {
399  ret = AVERROR(ENOMEM);
400  goto next;
401  }
402 
403  new_device->device_name = av_strdup(unique_name ? unique_name : display_name);
404  new_device->device_description = av_strdup(display_name);
405 
406  if (!new_device->device_name ||
407  !new_device->device_description ||
408  av_dynarray_add_nofree(&device_list->devices, &device_list->nb_devices, new_device) < 0) {
409  ret = AVERROR(ENOMEM);
410  av_freep(&new_device->device_name);
411  av_freep(&new_device->device_description);
412  av_freep(&new_device);
413  goto next;
414  }
415  }
416 
417  next:
418  av_freep(&display_name);
419  av_freep(&unique_name);
420  dl->Release();
421  }
422  iter->Release();
423  return ret;
424 }
425 
426 /* This is a wrapper around the ff_decklink_list_devices() which dumps the
427  output to av_log() and exits (for backward compatibility with the
428  "-list_devices" argument). */
430  int show_inputs, int show_outputs)
431 {
432  struct AVDeviceInfoList *device_list = NULL;
433  int ret;
434 
435  device_list = (struct AVDeviceInfoList *) av_mallocz(sizeof(AVDeviceInfoList));
436  if (!device_list)
437  return;
438 
439  ret = ff_decklink_list_devices(avctx, device_list, show_inputs, show_outputs);
440  if (ret == 0) {
441  av_log(avctx, AV_LOG_INFO, "Blackmagic DeckLink %s devices:\n",
442  show_inputs ? "input" : "output");
443  for (int i = 0; i < device_list->nb_devices; i++) {
444  av_log(avctx, AV_LOG_INFO, "\t'%s'\n", device_list->devices[i]->device_description);
445  }
446  }
447  avdevice_free_list_devices(&device_list);
448 }
449 
451 {
452  struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
453  struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
454  IDeckLinkDisplayModeIterator *itermode;
455  IDeckLinkDisplayMode *mode;
456  uint32_t format_code;
457  HRESULT res;
458 
459  if (direction == DIRECTION_IN) {
460  int ret;
461  ret = decklink_select_input(avctx, bmdDeckLinkConfigAudioInputConnection);
462  if (ret < 0)
463  return ret;
464  ret = decklink_select_input(avctx, bmdDeckLinkConfigVideoInputConnection);
465  if (ret < 0)
466  return ret;
467  res = ctx->dli->GetDisplayModeIterator (&itermode);
468  } else {
469  res = ctx->dlo->GetDisplayModeIterator (&itermode);
470  }
471 
472  if (res!= S_OK) {
473  av_log(avctx, AV_LOG_ERROR, "Could not get Display Mode Iterator\n");
474  return AVERROR(EIO);
475  }
476 
477  av_log(avctx, AV_LOG_INFO, "Supported formats for '%s':\n\tformat_code\tdescription",
478  avctx->url);
479  while (itermode->Next(&mode) == S_OK) {
480  BMDTimeValue tb_num, tb_den;
481  mode->GetFrameRate(&tb_num, &tb_den);
482  format_code = av_bswap32(mode->GetDisplayMode());
483  av_log(avctx, AV_LOG_INFO, "\n\t%.4s\t\t%ldx%ld at %d/%d fps",
484  (char*) &format_code, mode->GetWidth(), mode->GetHeight(),
485  (int) tb_den, (int) tb_num);
486  switch (mode->GetFieldDominance()) {
487  case bmdLowerFieldFirst:
488  av_log(avctx, AV_LOG_INFO, " (interlaced, lower field first)"); break;
489  case bmdUpperFieldFirst:
490  av_log(avctx, AV_LOG_INFO, " (interlaced, upper field first)"); break;
491  }
492  mode->Release();
493  }
494  av_log(avctx, AV_LOG_INFO, "\n");
495 
496  itermode->Release();
497 
498  return 0;
499 }
500 
502 {
503  struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
504  struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
505 
506  if (ctx->dli)
507  ctx->dli->Release();
508  if (ctx->dlo)
509  ctx->dlo->Release();
510  if (ctx->attr)
511  ctx->attr->Release();
512  if (ctx->cfg)
513  ctx->cfg->Release();
514  if (ctx->dl)
515  ctx->dl->Release();
516 }
517 
519 {
520  struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
521  struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
522  IDeckLink *dl = NULL;
523  IDeckLinkIterator *iter = decklink_create_iterator(avctx);
524  if (!iter)
525  return AVERROR_EXTERNAL;
526 
527  while (iter->Next(&dl) == S_OK) {
528  const char *display_name = NULL;
529  const char *unique_name = NULL;
530  decklink_get_attr_string(dl, BMDDeckLinkDisplayName, &display_name);
531  decklink_get_attr_string(dl, BMDDeckLinkDeviceHandle, &unique_name);
532  if (display_name && !strcmp(name, display_name) || unique_name && !strcmp(name, unique_name)) {
533  av_free((void *)unique_name);
534  av_free((void *)display_name);
535  ctx->dl = dl;
536  break;
537  }
538  av_free((void *)display_name);
539  av_free((void *)unique_name);
540  dl->Release();
541  }
542  iter->Release();
543  if (!ctx->dl)
544  return AVERROR(ENXIO);
545 
546  if (ctx->dl->QueryInterface(IID_IDeckLinkConfiguration, (void **)&ctx->cfg) != S_OK) {
547  av_log(avctx, AV_LOG_ERROR, "Could not get configuration interface for '%s'\n", name);
548  ff_decklink_cleanup(avctx);
549  return AVERROR_EXTERNAL;
550  }
551 
552  if (ctx->dl->QueryInterface(IID_IDeckLinkProfileAttributes, (void **)&ctx->attr) != S_OK) {
553  av_log(avctx, AV_LOG_ERROR, "Could not get attributes interface for '%s'\n", name);
554  ff_decklink_cleanup(avctx);
555  return AVERROR_EXTERNAL;
556  }
557 
558  return 0;
559 }
#define NULL
Definition: coverity.c:32
Structure describes basic parameters of the device.
Definition: avdevice.h:457
version
Definition: libkvazaar.c:320
char * device_description
human friendly name
Definition: avdevice.h:459
misc image utilities
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
char * device_name
device name, format depends on device
Definition: avdevice.h:458
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
Format I/O context.
Definition: avformat.h:1243
void avdevice_free_list_devices(AVDeviceInfoList **device_list)
Convenient function to free result of avdevice_list_devices().
Definition: avdevice.c:145
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:91
#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:210
int av_dynarray_add_nofree(void *tab_ptr, int *nb_ptr, void *elem)
Add an element to a dynamic array.
Definition: mem.c:296
#define av_log(a,...)
Main libavdevice API header.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
char * url
input or output URL.
Definition: avformat.h:1339
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
AVDeviceInfo ** devices
list of autodetected devices
Definition: avdevice.h:466
#define FFMIN(a, b)
Definition: common.h:105
#define width
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
#define AV_LOG_INFO
Standard information.
Definition: log.h:205
#define av_bswap32
Definition: bswap.h:33
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:253
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
byte swapping routines
List of devices.
Definition: avdevice.h:465
mfxU16 profile
Definition: qsvenc.c:45
AVFieldOrder
Definition: codec_par.h:36
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:1271
static float add(float src0, float src1)
#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:467
#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
int i
Definition: input.c:407
const char * name
Definition: opengl_enc.c:102
static uint8_t tmp[11]
Definition: aes_ctr.c:27