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