FFmpeg: libavdevice/decklink_common.cpp Source File

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 <DeckLinkAPI.h>
23 #ifdef _WIN32
24 #include <DeckLinkAPI_i.c>
25 #else
26 #include <DeckLinkAPIDispatch.cpp>
27 #endif
28 
29 #include <pthread.h>
30 #include <semaphore.h>
31 
32 extern "C" {
33 #include "libavformat/avformat.h"
34 #include "libavformat/internal.h"
35 #include "libavutil/imgutils.h"
36 }
37 
38 #include "decklink_common.h"
39 
40 #ifdef _WIN32
41 IDeckLinkIterator *CreateDeckLinkIteratorInstance(void)
42 {
43  IDeckLinkIterator *iter;
44 
45  if (CoInitialize(NULL) < 0) {
46  av_log(NULL, AV_LOG_ERROR, "COM initialization failed.\n");
47  return NULL;
48  }
49 
50  if (CoCreateInstance(CLSID_CDeckLinkIterator, NULL, CLSCTX_ALL,
51  IID_IDeckLinkIterator, (void**) &iter) != S_OK) {
52  av_log(NULL, AV_LOG_ERROR, "DeckLink drivers not installed.\n");
53  return NULL;
54  }
55 
56  return iter;
57 }
58 #endif
59 
60 #ifdef _WIN32
61 static char *dup_wchar_to_utf8(wchar_t *w)
62 {
63  char *s = NULL;
64  int l = WideCharToMultiByte(CP_UTF8, 0, w, -1, 0, 0, 0, 0);
65  s = (char *) av_malloc(l);
66  if (s)
67  WideCharToMultiByte(CP_UTF8, 0, w, -1, s, l, 0, 0);
68  return s;
69 }
70 #define DECKLINK_STR OLECHAR *
71 #define DECKLINK_STRDUP dup_wchar_to_utf8
72 #define DECKLINK_FREE(s) SysFreeString(s)
73 #define DECKLINK_BOOL BOOL
74 #elif defined(__APPLE__)
75 static char *dup_cfstring_to_utf8(CFStringRef w)
76 {
77  char s[256];
78  CFStringGetCString(w, s, 255, kCFStringEncodingUTF8);
79  return av_strdup(s);
80 }
81 #define DECKLINK_STR const __CFString *
82 #define DECKLINK_STRDUP dup_cfstring_to_utf8
83 #define DECKLINK_FREE(s) free((void *) s)
84 #define DECKLINK_BOOL bool
85 #else
86  #define DECKLINK_STR const char *
87  #define DECKLINK_STRDUP av_strdup
88 /* free() is needed for a string returned by the DeckLink SDL. */
89  #define DECKLINK_FREE(s) free((void *) s)
90  #define DECKLINK_BOOL bool
91 #endif
92 
93  HRESULT ff_decklink_get_display_name(IDeckLink *This, const char **displayName)
94 {
95  DECKLINK_STR tmpDisplayName;
96  HRESULT hr = This->GetDisplayName(&tmpDisplayName);
97  if (hr != S_OK)
98  return hr;
99  *displayName = DECKLINK_STRDUP(tmpDisplayName);
100  DECKLINK_FREE(tmpDisplayName);
101  return hr;
102 }
103 
104  static int decklink_select_input(AVFormatContext *avctx, BMDDeckLinkConfigurationID cfg_id)
105 {
106  struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
107  struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
108  BMDDeckLinkAttributeID attr_id = (cfg_id == bmdDeckLinkConfigAudioInputConnection) ? BMDDeckLinkAudioInputConnections : BMDDeckLinkVideoInputConnections;
109  int64_t bmd_input = (cfg_id == bmdDeckLinkConfigAudioInputConnection) ? (int64_t)ctx->audio_input : (int64_t)ctx->video_input;
110  const char *type_name = (cfg_id == bmdDeckLinkConfigAudioInputConnection) ? "audio" : "video";
111  int64_t supported_connections = 0;
112  HRESULT res;
113 
114  if (bmd_input) {
115  res = ctx->attr->GetInt(attr_id, &supported_connections);
116  if (res != S_OK) {
117  av_log(avctx, AV_LOG_ERROR, "Failed to query supported %s inputs.\n", type_name);
118  return AVERROR_EXTERNAL;
119  }
120  if ((supported_connections & bmd_input) != bmd_input) {
121  av_log(avctx, AV_LOG_ERROR, "Device does not support selected %s input.\n", type_name);
122  return AVERROR(ENOSYS);
123  }
124  res = ctx->cfg->SetInt(cfg_id, bmd_input);
125  if (res != S_OK) {
126  av_log(avctx, AV_LOG_ERROR, "Failed to select %s input.\n", type_name);
127  return AVERROR_EXTERNAL;
128  }
129  }
130  return 0;
131 }
132 
133  int ff_decklink_set_format(AVFormatContext *avctx,
134  int width, int height,
135  int tb_num, int tb_den,
136  decklink_direction_t direction, int num)
137 {
138  struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
139  struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
140  BMDDisplayModeSupport support;
141  IDeckLinkDisplayModeIterator *itermode;
142  IDeckLinkDisplayMode *mode;
143  int i = 1;
144  HRESULT res;
145 
146  av_log(avctx, AV_LOG_DEBUG, "Trying to find mode for frame size %dx%d, frame timing %d/%d, direction %d, mode number %d\n",
147  width, height, tb_num, tb_den, direction, num);
148 
149  if (ctx->duplex_mode) {
150  DECKLINK_BOOL duplex_supported = false;
151 
152  if (ctx->attr->GetFlag(BMDDeckLinkSupportsDuplexModeConfiguration, &duplex_supported) != S_OK)
153  duplex_supported = false;
154 
155  if (duplex_supported) {
156  res = ctx->cfg->SetInt(bmdDeckLinkConfigDuplexMode, ctx->duplex_mode == 2 ? bmdDuplexModeFull : bmdDuplexModeHalf);
157  if (res != S_OK)
158  av_log(avctx, AV_LOG_WARNING, "Setting duplex mode failed.\n");
159  else
160  av_log(avctx, AV_LOG_VERBOSE, "Successfully set duplex mode to %s duplex.\n", ctx->duplex_mode == 2 ? "full" : "half");
161  } else {
162  av_log(avctx, AV_LOG_WARNING, "Unable to set duplex mode, because it is not supported.\n");
163  }
164  }
165 
166  if (direction == DIRECTION_IN) {
167  int ret;
168  ret = decklink_select_input(avctx, bmdDeckLinkConfigAudioInputConnection);
169  if (ret < 0)
170  return ret;
171  ret = decklink_select_input(avctx, bmdDeckLinkConfigVideoInputConnection);
172  if (ret < 0)
173  return ret;
174  res = ctx->dli->GetDisplayModeIterator (&itermode);
175  } else {
176  res = ctx->dlo->GetDisplayModeIterator (&itermode);
177  }
178 
179  if (res!= S_OK) {
180  av_log(avctx, AV_LOG_ERROR, "Could not get Display Mode Iterator\n");
181  return AVERROR(EIO);
182  }
183 
184  AVRational target_tb = av_make_q(tb_num, tb_den);
185  ctx->bmd_mode = bmdModeUnknown;
186  while ((ctx->bmd_mode == bmdModeUnknown) && itermode->Next(&mode) == S_OK) {
187  BMDTimeValue bmd_tb_num, bmd_tb_den;
188  int bmd_width = mode->GetWidth();
189  int bmd_height = mode->GetHeight();
190 
191  mode->GetFrameRate(&bmd_tb_num, &bmd_tb_den);
192  AVRational mode_tb = av_make_q(bmd_tb_num, bmd_tb_den);
193 
194  if ((bmd_width == width && bmd_height == height &&
195  !av_cmp_q(mode_tb, target_tb)) || i == num) {
196  ctx->bmd_mode = mode->GetDisplayMode();
197  ctx->bmd_width = bmd_width;
198  ctx->bmd_height = bmd_height;
199  ctx->bmd_tb_den = bmd_tb_den;
200  ctx->bmd_tb_num = bmd_tb_num;
201  ctx->bmd_field_dominance = mode->GetFieldDominance();
202  av_log(avctx, AV_LOG_INFO, "Found Decklink mode %d x %d with rate %.2f%s\n",
203  bmd_width, bmd_height, 1/av_q2d(mode_tb),
204  (ctx->bmd_field_dominance==bmdLowerFieldFirst || ctx->bmd_field_dominance==bmdUpperFieldFirst)?"(i)":"");
205  }
206 
207  mode->Release();
208  i++;
209  }
210 
211  itermode->Release();
212 
213  if (ctx->bmd_mode == bmdModeUnknown)
214  return -1;
215  if (direction == DIRECTION_IN) {
216  if (ctx->dli->DoesSupportVideoMode(ctx->bmd_mode, bmdFormat8BitYUV,
217  bmdVideoOutputFlagDefault,
218  &support, NULL) != S_OK)
219  return -1;
220  } else {
221  if (ctx->dlo->DoesSupportVideoMode(ctx->bmd_mode, bmdFormat8BitYUV,
222  bmdVideoOutputFlagDefault,
223  &support, NULL) != S_OK)
224  return -1;
225  }
226  if (support == bmdDisplayModeSupported)
227  return 0;
228 
229  return -1;
230 }
231 
232  int ff_decklink_set_format(AVFormatContext *avctx, decklink_direction_t direction, int num) {
233  return ff_decklink_set_format(avctx, 0, 0, 0, 0, direction, num);
234 }
235 
236  int ff_decklink_list_devices(AVFormatContext *avctx)
237 {
238  IDeckLink *dl = NULL;
239  IDeckLinkIterator *iter = CreateDeckLinkIteratorInstance();
240  if (!iter) {
241  av_log(avctx, AV_LOG_ERROR, "Could not create DeckLink iterator\n");
242  return AVERROR(EIO);
243  }
244  av_log(avctx, AV_LOG_INFO, "Blackmagic DeckLink devices:\n");
245  while (iter->Next(&dl) == S_OK) {
246  const char *displayName;
247  ff_decklink_get_display_name(dl, &displayName);
248  av_log(avctx, AV_LOG_INFO, "\t'%s'\n", displayName);
249  av_free((void *) displayName);
250  dl->Release();
251  }
252  iter->Release();
253  return 0;
254 }
255 
256  int ff_decklink_list_formats(AVFormatContext *avctx, decklink_direction_t direction)
257 {
258  struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
259  struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
260  IDeckLinkDisplayModeIterator *itermode;
261  IDeckLinkDisplayMode *mode;
262  int i=0;
263  HRESULT res;
264 
265  if (direction == DIRECTION_IN) {
266  int ret;
267  ret = decklink_select_input(avctx, bmdDeckLinkConfigAudioInputConnection);
268  if (ret < 0)
269  return ret;
270  ret = decklink_select_input(avctx, bmdDeckLinkConfigVideoInputConnection);
271  if (ret < 0)
272  return ret;
273  res = ctx->dli->GetDisplayModeIterator (&itermode);
274  } else {
275  res = ctx->dlo->GetDisplayModeIterator (&itermode);
276  }
277 
278  if (res!= S_OK) {
279  av_log(avctx, AV_LOG_ERROR, "Could not get Display Mode Iterator\n");
280  return AVERROR(EIO);
281  }
282 
283  av_log(avctx, AV_LOG_INFO, "Supported formats for '%s':\n",
284  avctx->filename);
285  while (itermode->Next(&mode) == S_OK) {
286  BMDTimeValue tb_num, tb_den;
287  mode->GetFrameRate(&tb_num, &tb_den);
288  av_log(avctx, AV_LOG_INFO, "\t%d\t%ldx%ld at %d/%d fps",
289  ++i,mode->GetWidth(), mode->GetHeight(),
290  (int) tb_den, (int) tb_num);
291  switch (mode->GetFieldDominance()) {
292  case bmdLowerFieldFirst:
293  av_log(avctx, AV_LOG_INFO, " (interlaced, lower field first)"); break;
294  case bmdUpperFieldFirst:
295  av_log(avctx, AV_LOG_INFO, " (interlaced, upper field first)"); break;
296  }
297  av_log(avctx, AV_LOG_INFO, "\n");
298  mode->Release();
299  }
300 
301  itermode->Release();
302 
303  return 0;
304 }
305 
306  void ff_decklink_cleanup(AVFormatContext *avctx)
307 {
308  struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
309  struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
310 
311  if (ctx->dli)
312  ctx->dli->Release();
313  if (ctx->dlo)
314  ctx->dlo->Release();
315  if (ctx->attr)
316  ctx->attr->Release();
317  if (ctx->cfg)
318  ctx->cfg->Release();
319  if (ctx->dl)
320  ctx->dl->Release();
321 }
322 
323  int ff_decklink_init_device(AVFormatContext *avctx, const char* name)
324 {
325  struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
326  struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
327  IDeckLink *dl = NULL;
328  IDeckLinkIterator *iter = CreateDeckLinkIteratorInstance();
329  if (!iter) {
330  av_log(avctx, AV_LOG_ERROR, "Could not create DeckLink iterator\n");
331  return AVERROR_EXTERNAL;
332  }
333 
334  while (iter->Next(&dl) == S_OK) {
335  const char *displayName;
336  ff_decklink_get_display_name(dl, &displayName);
337  if (!strcmp(name, displayName)) {
338  av_free((void *)displayName);
339  ctx->dl = dl;
340  break;
341  }
342  av_free((void *)displayName);
343  dl->Release();
344  }
345  iter->Release();
346  if (!ctx->dl)
347  return AVERROR(ENXIO);
348 
349  if (ctx->dl->QueryInterface(IID_IDeckLinkConfiguration, (void **)&ctx->cfg) != S_OK) {
350  av_log(avctx, AV_LOG_ERROR, "Could not get configuration interface for '%s'\n", name);
351  ff_decklink_cleanup(avctx);
352  return AVERROR_EXTERNAL;
353  }
354 
355  if (ctx->dl->QueryInterface(IID_IDeckLinkAttributes, (void **)&ctx->attr) != S_OK) {
356  av_log(avctx, AV_LOG_ERROR, "Could not get attributes interface for '%s'\n", name);
357  ff_decklink_cleanup(avctx);
358  return AVERROR_EXTERNAL;
359  }
360 
361  return 0;
362 }
NULL
#define NULL
Definition: coverity.c:32
s
const char * s
Definition: avisynth_c.h:768
decklink_cctx::ctx
void * ctx
Definition: decklink_common_c.h:35
S_OK
#define S_OK
Definition: windows2linux.h:40
DECKLINK_STRDUP
#define DECKLINK_STRDUP
Definition: decklink_common.cpp:87
imgutils.h
misc image utilities
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
ff_decklink_init_device
int ff_decklink_init_device(AVFormatContext *avctx, const char *name)
Definition: decklink_common.cpp:323
DECKLINK_BOOL
#define DECKLINK_BOOL
Definition: decklink_common.cpp:90
AVFormatContext
Format I/O context.
Definition: avformat.h:1338
DIRECTION_IN
Definition: decklink_common.h:97
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
mode
mode
Definition: f_perms.c:27
decklink_cctx
Definition: decklink_common_c.h:32
height
#define height
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
ff_decklink_set_format
int ff_decklink_set_format(AVFormatContext *avctx, int width, int height, int tb_num, int tb_den, decklink_direction_t direction, int num)
Definition: decklink_common.cpp:133
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
AVERROR
#define AVERROR(e)
Definition: error.h:43
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
decklink_ctx
Definition: decklink_common.h:42
dup_wchar_to_utf8
static char * dup_wchar_to_utf8(wchar_t *w)
Definition: dshow.c:132
AVFormatContext::filename
char filename[1024]
input or output filename
Definition: avformat.h:1414
width
#define width
ctx
AVFormatContext * ctx
Definition: movenc.c:48
ff_decklink_list_formats
int ff_decklink_list_formats(AVFormatContext *avctx, decklink_direction_t direction)
Definition: decklink_common.cpp:256
decklink_common.h
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:267
ff_decklink_list_devices
int ff_decklink_list_devices(AVFormatContext *avctx)
Definition: decklink_common.cpp:236
av_make_q
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition: rational.h:71
decklink_select_input
static int decklink_select_input(AVFormatContext *avctx, BMDDeckLinkConfigurationID cfg_id)
Definition: decklink_common.cpp:104
ff_decklink_get_display_name
HRESULT ff_decklink_get_display_name(IDeckLink *This, const char **displayName)
Definition: decklink_common.cpp:93
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
decklink_direction_t
decklink_direction_t
Definition: decklink_common.h:97
HRESULT
DWORD HRESULT
Definition: basicDataTypeConversions.h:54
DECKLINK_STR
#define DECKLINK_STR
Definition: decklink_common.cpp:86
ff_decklink_cleanup
void ff_decklink_cleanup(AVFormatContext *avctx)
Definition: decklink_common.cpp:306
av_cmp_q
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
avformat.h
Main libavformat public API header.
DECKLINK_FREE
#define DECKLINK_FREE(s)
Definition: decklink_common.cpp:89
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1366
AVERROR_EXTERNAL
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:57
name
const char * name
Definition: opengl_enc.c:103
Generated on Thu Oct 27 2016 19:33:34 for FFmpeg by   doxygen 1.8.6

AltStyle によって変換されたページ (->オリジナル) /