FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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 #ifdef _WIN32
57 IDeckLinkIterator *CreateDeckLinkIteratorInstance(void)
58 {
59  IDeckLinkIterator *iter;
60 
61  if (CoInitialize(NULL) < 0) {
62  av_log(NULL, 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  av_log(NULL, AV_LOG_ERROR, "DeckLink drivers not installed.\n");
69  return NULL;
70  }
71 
72  return iter;
73 }
74 #endif
75 
76 #ifdef _WIN32
77 static char *dup_wchar_to_utf8(wchar_t *w)
78 {
79  char *s = NULL;
80  int l = WideCharToMultiByte(CP_UTF8, 0, w, -1, 0, 0, 0, 0);
81  s = (char *) av_malloc(l);
82  if (s)
83  WideCharToMultiByte(CP_UTF8, 0, w, -1, s, l, 0, 0);
84  return s;
85 }
86 #define DECKLINK_STR OLECHAR *
87 #define DECKLINK_STRDUP dup_wchar_to_utf8
88 #define DECKLINK_FREE(s) SysFreeString(s)
89 #elif defined(__APPLE__)
90 static char *dup_cfstring_to_utf8(CFStringRef w)
91 {
92  char s[256];
93  CFStringGetCString(w, s, 255, kCFStringEncodingUTF8);
94  return av_strdup(s);
95 }
96 #define DECKLINK_STR const __CFString *
97 #define DECKLINK_STRDUP dup_cfstring_to_utf8
98 #define DECKLINK_FREE(s) CFRelease(s)
99 #else
100 #define DECKLINK_STR const char *
101 #define DECKLINK_STRDUP av_strdup
102 /* free() is needed for a string returned by the DeckLink SDL. */
103 #define DECKLINK_FREE(s) free((void *) s)
104 #endif
105 
106 HRESULT ff_decklink_get_display_name(IDeckLink *This, const char **displayName)
107 {
108  DECKLINK_STR tmpDisplayName;
109  HRESULT hr = This->GetDisplayName(&tmpDisplayName);
110  if (hr != S_OK)
111  return hr;
112  *displayName = DECKLINK_STRDUP(tmpDisplayName);
113  DECKLINK_FREE(tmpDisplayName);
114  return hr;
115 }
116 
117 static int decklink_select_input(AVFormatContext *avctx, BMDDeckLinkConfigurationID cfg_id)
118 {
119  struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
120  struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
121  BMDDeckLinkAttributeID attr_id = (cfg_id == bmdDeckLinkConfigAudioInputConnection) ? BMDDeckLinkAudioInputConnections : BMDDeckLinkVideoInputConnections;
122  int64_t bmd_input = (cfg_id == bmdDeckLinkConfigAudioInputConnection) ? (int64_t)ctx->audio_input : (int64_t)ctx->video_input;
123  const char *type_name = (cfg_id == bmdDeckLinkConfigAudioInputConnection) ? "audio" : "video";
124  int64_t supported_connections = 0;
125  HRESULT res;
126 
127  if (bmd_input) {
128  res = ctx->attr->GetInt(attr_id, &supported_connections);
129  if (res != S_OK) {
130  av_log(avctx, AV_LOG_ERROR, "Failed to query supported %s inputs.\n", type_name);
131  return AVERROR_EXTERNAL;
132  }
133  if ((supported_connections & bmd_input) != bmd_input) {
134  av_log(avctx, AV_LOG_ERROR, "Device does not support selected %s input.\n", type_name);
135  return AVERROR(ENOSYS);
136  }
137  res = ctx->cfg->SetInt(cfg_id, bmd_input);
138  if (res != S_OK) {
139  av_log(avctx, AV_LOG_ERROR, "Failed to select %s input.\n", type_name);
140  return AVERROR_EXTERNAL;
141  }
142  }
143  return 0;
144 }
145 
146 static DECKLINK_BOOL field_order_eq(enum AVFieldOrder field_order, BMDFieldDominance bmd_field_order)
147 {
148  if (field_order == AV_FIELD_UNKNOWN)
149  return true;
150  if ((field_order == AV_FIELD_TT || field_order == AV_FIELD_TB) && bmd_field_order == bmdUpperFieldFirst)
151  return true;
152  if ((field_order == AV_FIELD_BB || field_order == AV_FIELD_BT) && bmd_field_order == bmdLowerFieldFirst)
153  return true;
154  if (field_order == AV_FIELD_PROGRESSIVE && (bmd_field_order == bmdProgressiveFrame || bmd_field_order == bmdProgressiveSegmentedFrame))
155  return true;
156  return false;
157 }
158 
160  decklink_direction_t direction) {
161  struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
162  struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
163  HRESULT res;
164 
165  if (ctx->duplex_mode) {
166  DECKLINK_BOOL duplex_supported = false;
167 
168  if (ctx->attr->GetFlag(BMDDeckLinkSupportsDuplexModeConfiguration, &duplex_supported) != S_OK)
169  duplex_supported = false;
170 
171  if (duplex_supported) {
172  res = ctx->cfg->SetInt(bmdDeckLinkConfigDuplexMode, ctx->duplex_mode == 2 ? bmdDuplexModeFull : bmdDuplexModeHalf);
173  if (res != S_OK)
174  av_log(avctx, AV_LOG_WARNING, "Setting duplex mode failed.\n");
175  else
176  av_log(avctx, AV_LOG_VERBOSE, "Successfully set duplex mode to %s duplex.\n", ctx->duplex_mode == 2 ? "full" : "half");
177  } else {
178  av_log(avctx, AV_LOG_WARNING, "Unable to set duplex mode, because it is not supported.\n");
179  }
180  }
181  if (direction == DIRECTION_IN) {
182  int ret;
183  ret = decklink_select_input(avctx, bmdDeckLinkConfigAudioInputConnection);
184  if (ret < 0)
185  return ret;
186  ret = decklink_select_input(avctx, bmdDeckLinkConfigVideoInputConnection);
187  if (ret < 0)
188  return ret;
189  }
190  return 0;
191 }
192 
194  int width, int height,
195  int tb_num, int tb_den,
196  enum AVFieldOrder field_order,
197  decklink_direction_t direction, int num)
198 {
199  struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
200  struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
201  BMDDisplayModeSupport support;
202  IDeckLinkDisplayModeIterator *itermode;
203  IDeckLinkDisplayMode *mode;
204  int i = 1;
205  HRESULT res;
206 
207  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",
208  width, height, tb_num, tb_den, field_order, direction, num, (cctx->format_code) ? cctx->format_code : "(unset)");
209 
210  if (direction == DIRECTION_IN) {
211  res = ctx->dli->GetDisplayModeIterator (&itermode);
212  } else {
213  res = ctx->dlo->GetDisplayModeIterator (&itermode);
214  }
215 
216  if (res!= S_OK) {
217  av_log(avctx, AV_LOG_ERROR, "Could not get Display Mode Iterator\n");
218  return AVERROR(EIO);
219  }
220 
221  char format_buf[] = " ";
222  if (cctx->format_code)
223  memcpy(format_buf, cctx->format_code, FFMIN(strlen(cctx->format_code), sizeof(format_buf)));
224  BMDDisplayMode target_mode = (BMDDisplayMode)AV_RB32(format_buf);
225  AVRational target_tb = av_make_q(tb_num, tb_den);
226  ctx->bmd_mode = bmdModeUnknown;
227  while ((ctx->bmd_mode == bmdModeUnknown) && itermode->Next(&mode) == S_OK) {
228  BMDTimeValue bmd_tb_num, bmd_tb_den;
229  int bmd_width = mode->GetWidth();
230  int bmd_height = mode->GetHeight();
231  BMDDisplayMode bmd_mode = mode->GetDisplayMode();
232  BMDFieldDominance bmd_field_dominance = mode->GetFieldDominance();
233 
234  mode->GetFrameRate(&bmd_tb_num, &bmd_tb_den);
235  AVRational mode_tb = av_make_q(bmd_tb_num, bmd_tb_den);
236 
237  if ((bmd_width == width &&
238  bmd_height == height &&
239  !av_cmp_q(mode_tb, target_tb) &&
240  field_order_eq(field_order, bmd_field_dominance))
241  || i == num
242  || target_mode == bmd_mode) {
243  ctx->bmd_mode = bmd_mode;
244  ctx->bmd_width = bmd_width;
245  ctx->bmd_height = bmd_height;
246  ctx->bmd_tb_den = bmd_tb_den;
247  ctx->bmd_tb_num = bmd_tb_num;
248  ctx->bmd_field_dominance = bmd_field_dominance;
249  av_log(avctx, AV_LOG_INFO, "Found Decklink mode %d x %d with rate %.2f%s\n",
250  bmd_width, bmd_height, 1/av_q2d(mode_tb),
251  (ctx->bmd_field_dominance==bmdLowerFieldFirst || ctx->bmd_field_dominance==bmdUpperFieldFirst)?"(i)":"");
252  }
253 
254  mode->Release();
255  i++;
256  }
257 
258  itermode->Release();
259 
260  if (ctx->bmd_mode == bmdModeUnknown)
261  return -1;
262  if (direction == DIRECTION_IN) {
263  if (ctx->dli->DoesSupportVideoMode(ctx->bmd_mode, (BMDPixelFormat) cctx->raw_format,
264  bmdVideoOutputFlagDefault,
265  &support, NULL) != S_OK)
266  return -1;
267  } else {
268  if (ctx->dlo->DoesSupportVideoMode(ctx->bmd_mode, bmdFormat8BitYUV,
269  bmdVideoOutputFlagDefault,
270  &support, NULL) != S_OK)
271  return -1;
272  }
273  if (support == bmdDisplayModeSupported)
274  return 0;
275 
276  return -1;
277 }
278 
280  return ff_decklink_set_format(avctx, 0, 0, 0, 0, AV_FIELD_UNKNOWN, direction, num);
281 }
282 
284  struct AVDeviceInfoList *device_list,
285  int show_inputs, int show_outputs)
286 {
287  IDeckLink *dl = NULL;
288  IDeckLinkIterator *iter = CreateDeckLinkIteratorInstance();
289  int ret = 0;
290 
291  if (!iter) {
292  av_log(avctx, AV_LOG_ERROR, "Could not create DeckLink iterator\n");
293  return AVERROR(EIO);
294  }
295 
296  while (ret == 0 && iter->Next(&dl) == S_OK) {
297  IDeckLinkOutput *output_config;
298  IDeckLinkInput *input_config;
299  const char *displayName;
300  AVDeviceInfo *new_device = NULL;
301  int add = 0;
302 
303  ff_decklink_get_display_name(dl, &displayName);
304 
305  if (show_outputs) {
306  if (dl->QueryInterface(IID_IDeckLinkOutput, (void **)&output_config) == S_OK) {
307  output_config->Release();
308  add = 1;
309  }
310  }
311 
312  if (show_inputs) {
313  if (dl->QueryInterface(IID_IDeckLinkInput, (void **)&input_config) == S_OK) {
314  input_config->Release();
315  add = 1;
316  }
317  }
318 
319  if (add == 1) {
320  new_device = (AVDeviceInfo *) av_mallocz(sizeof(AVDeviceInfo));
321  if (!new_device) {
322  ret = AVERROR(ENOMEM);
323  goto next;
324  }
325 
326  new_device->device_name = av_strdup(displayName);
327  new_device->device_description = av_strdup(displayName);
328 
329  if (!new_device->device_name ||
330  !new_device->device_description ||
331  av_dynarray_add_nofree(&device_list->devices, &device_list->nb_devices, new_device) < 0) {
332  ret = AVERROR(ENOMEM);
333  av_freep(&new_device->device_name);
334  av_freep(&new_device->device_description);
335  av_freep(&new_device);
336  goto next;
337  }
338  }
339 
340  next:
341  av_freep(&displayName);
342  dl->Release();
343  }
344  iter->Release();
345  return ret;
346 }
347 
348 /* This is a wrapper around the ff_decklink_list_devices() which dumps the
349  output to av_log() and exits (for backward compatibility with the
350  "-list_devices" argument). */
352  int show_inputs, int show_outputs)
353 {
354  struct AVDeviceInfoList *device_list = NULL;
355  int ret;
356 
357  device_list = (struct AVDeviceInfoList *) av_mallocz(sizeof(AVDeviceInfoList));
358  if (!device_list)
359  return;
360 
361  ret = ff_decklink_list_devices(avctx, device_list, show_inputs, show_outputs);
362  if (ret == 0) {
363  av_log(avctx, AV_LOG_INFO, "Blackmagic DeckLink %s devices:\n",
364  show_inputs ? "input" : "output");
365  for (int i = 0; i < device_list->nb_devices; i++) {
366  av_log(avctx, AV_LOG_INFO, "\t'%s'\n", device_list->devices[i]->device_name);
367  }
368  }
369  avdevice_free_list_devices(&device_list);
370 }
371 
373 {
374  struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
375  struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
376  IDeckLinkDisplayModeIterator *itermode;
377  IDeckLinkDisplayMode *mode;
378  uint32_t format_code;
379  HRESULT res;
380 
381  if (direction == DIRECTION_IN) {
382  int ret;
383  ret = decklink_select_input(avctx, bmdDeckLinkConfigAudioInputConnection);
384  if (ret < 0)
385  return ret;
386  ret = decklink_select_input(avctx, bmdDeckLinkConfigVideoInputConnection);
387  if (ret < 0)
388  return ret;
389  res = ctx->dli->GetDisplayModeIterator (&itermode);
390  } else {
391  res = ctx->dlo->GetDisplayModeIterator (&itermode);
392  }
393 
394  if (res!= S_OK) {
395  av_log(avctx, AV_LOG_ERROR, "Could not get Display Mode Iterator\n");
396  return AVERROR(EIO);
397  }
398 
399  av_log(avctx, AV_LOG_INFO, "Supported formats for '%s':\n\tformat_code\tdescription",
400  avctx->url);
401  while (itermode->Next(&mode) == S_OK) {
402  BMDTimeValue tb_num, tb_den;
403  mode->GetFrameRate(&tb_num, &tb_den);
404  format_code = av_bswap32(mode->GetDisplayMode());
405  av_log(avctx, AV_LOG_INFO, "\n\t%.4s\t\t%ldx%ld at %d/%d fps",
406  (char*) &format_code, mode->GetWidth(), mode->GetHeight(),
407  (int) tb_den, (int) tb_num);
408  switch (mode->GetFieldDominance()) {
409  case bmdLowerFieldFirst:
410  av_log(avctx, AV_LOG_INFO, " (interlaced, lower field first)"); break;
411  case bmdUpperFieldFirst:
412  av_log(avctx, AV_LOG_INFO, " (interlaced, upper field first)"); break;
413  }
414  mode->Release();
415  }
416  av_log(avctx, AV_LOG_INFO, "\n");
417 
418  itermode->Release();
419 
420  return 0;
421 }
422 
424 {
425  struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
426  struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
427 
428  if (ctx->dli)
429  ctx->dli->Release();
430  if (ctx->dlo)
431  ctx->dlo->Release();
432  if (ctx->attr)
433  ctx->attr->Release();
434  if (ctx->cfg)
435  ctx->cfg->Release();
436  if (ctx->dl)
437  ctx->dl->Release();
438 }
439 
441 {
442  struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
443  struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
444  IDeckLink *dl = NULL;
445  IDeckLinkIterator *iter = CreateDeckLinkIteratorInstance();
446  if (!iter) {
447  av_log(avctx, AV_LOG_ERROR, "Could not create DeckLink iterator\n");
448  return AVERROR_EXTERNAL;
449  }
450 
451  while (iter->Next(&dl) == S_OK) {
452  const char *displayName;
453  ff_decklink_get_display_name(dl, &displayName);
454  if (!strcmp(name, displayName)) {
455  av_free((void *)displayName);
456  ctx->dl = dl;
457  break;
458  }
459  av_free((void *)displayName);
460  dl->Release();
461  }
462  iter->Release();
463  if (!ctx->dl)
464  return AVERROR(ENXIO);
465 
466  if (ctx->dl->QueryInterface(IID_IDeckLinkConfiguration, (void **)&ctx->cfg) != S_OK) {
467  av_log(avctx, AV_LOG_ERROR, "Could not get configuration interface for '%s'\n", name);
468  ff_decklink_cleanup(avctx);
469  return AVERROR_EXTERNAL;
470  }
471 
472  if (ctx->dl->QueryInterface(IID_IDeckLinkAttributes, (void **)&ctx->attr) != S_OK) {
473  av_log(avctx, AV_LOG_ERROR, "Could not get attributes interface for '%s'\n", name);
474  ff_decklink_cleanup(avctx);
475  return AVERROR_EXTERNAL;
476  }
477 
478  return 0;
479 }
#define NULL
Definition: coverity.c:32
Structure describes basic parameters of the device.
Definition: avdevice.h:452
const char * s
Definition: avisynth_c.h:768
#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:1342
#define av_malloc(s)
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 AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define AVERROR(e)
Definition: error.h:43
char * url
input or output URL.
Definition: avformat.h:1438
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
uint16_t width
Definition: gdv.c:47
AVDeviceInfo ** devices
list of autodetected devices
Definition: avdevice.h:461
static char * dup_wchar_to_utf8(wchar_t *w)
Definition: dshow.c:132
#define FFMIN(a, b)
Definition: common.h:96
uint8_t w
Definition: llviddspenc.c:38
AVFormatContext * ctx
Definition: movenc.c:48
#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:1496
byte swapping routines
List of devices.
Definition: avdevice.h:460
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:1370
#define av_freep(p)
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'ed).
Definition: ebur128.h:83
const char * name
Definition: opengl_enc.c:103