avdevice/decklink: add support for setting duplex mode
[ffmpeg.git] / libavdevice / decklink_common.cpp
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 #elif defined(__APPLE__)
74 static char *dup_cfstring_to_utf8(CFStringRef w)
75 {
76     char s[256];
77     CFStringGetCString(w, s, 255, kCFStringEncodingUTF8);
78     return av_strdup(s);
79 }
80 #define DECKLINK_STR    const __CFString *
81 #define DECKLINK_STRDUP dup_cfstring_to_utf8
82 #define DECKLINK_FREE(s) free((void *) s)
83 #else
84 #define DECKLINK_STR    const char *
85 #define DECKLINK_STRDUP av_strdup
86 /* free() is needed for a string returned by the DeckLink SDL. */
87 #define DECKLINK_FREE(s) free((void *) s)
88 #endif
89
90 HRESULT ff_decklink_get_display_name(IDeckLink *This, const char **displayName)
91 {
92     DECKLINK_STR tmpDisplayName;
93     HRESULT hr = This->GetDisplayName(&tmpDisplayName);
94     if (hr != S_OK)
95         return hr;
96     *displayName = DECKLINK_STRDUP(tmpDisplayName);
97     DECKLINK_FREE(tmpDisplayName);
98     return hr;
99 }
100
101 int ff_decklink_set_format(AVFormatContext *avctx,
102                                int width, int height,
103                                int tb_num, int tb_den,
104                                decklink_direction_t direction, int num)
105 {
106     struct decklink_cctx *cctx = (struct decklink_cctx *) avctx->priv_data;
107     struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
108     BMDDisplayModeSupport support;
109     IDeckLinkDisplayModeIterator *itermode;
110     IDeckLinkDisplayMode *mode;
111     int i = 1;
112     HRESULT res;
113
114     if (ctx->duplex_mode) {
115         bool duplex_supported = false;
116
117         if (ctx->attr->GetFlag(BMDDeckLinkSupportsDuplexModeConfiguration, &duplex_supported) != S_OK)
118             duplex_supported = false;
119
120         if (duplex_supported) {
121             res = ctx->cfg->SetInt(bmdDeckLinkConfigDuplexMode, ctx->duplex_mode == 2 ? bmdDuplexModeFull : bmdDuplexModeHalf);
122             if (res != S_OK)
123                 av_log(avctx, AV_LOG_WARNING, "Setting duplex mode failed.\n");
124             else
125                 av_log(avctx, AV_LOG_VERBOSE, "Succesfully set duplex mode to %s duplex.\n", ctx->duplex_mode == 2 ? "full" : "half");
126         } else {
127             av_log(avctx, AV_LOG_WARNING, "Unable to set duplex mode, because it is not supported.\n");
128         }
129     }
130
131     if (direction == DIRECTION_IN) {
132         res = ctx->dli->GetDisplayModeIterator (&itermode);
133     } else {
134         res = ctx->dlo->GetDisplayModeIterator (&itermode);
135     }
136
137     if (res!= S_OK) {
138             av_log(avctx, AV_LOG_ERROR, "Could not get Display Mode Iterator\n");
139             return AVERROR(EIO);
140     }
141
142
143     if (tb_num == 1) {
144         tb_num *= 1000;
145         tb_den *= 1000;
146     }
147     ctx->bmd_mode = bmdModeUnknown;
148     while ((ctx->bmd_mode == bmdModeUnknown) && itermode->Next(&mode) == S_OK) {
149         BMDTimeValue bmd_tb_num, bmd_tb_den;
150         int bmd_width  = mode->GetWidth();
151         int bmd_height = mode->GetHeight();
152
153         mode->GetFrameRate(&bmd_tb_num, &bmd_tb_den);
154
155         if ((bmd_width == width && bmd_height == height &&
156             bmd_tb_num == tb_num && bmd_tb_den == tb_den) || i == num) {
157             ctx->bmd_mode   = mode->GetDisplayMode();
158             ctx->bmd_width  = bmd_width;
159             ctx->bmd_height = bmd_height;
160             ctx->bmd_tb_den = bmd_tb_den;
161             ctx->bmd_tb_num = bmd_tb_num;
162             ctx->bmd_field_dominance = mode->GetFieldDominance();
163             av_log(avctx, AV_LOG_INFO, "Found Decklink mode %d x %d with rate %.2f%s\n",
164                 bmd_width, bmd_height, (float)bmd_tb_den/(float)bmd_tb_num,
165                 (ctx->bmd_field_dominance==bmdLowerFieldFirst || ctx->bmd_field_dominance==bmdUpperFieldFirst)?"(i)":"");
166         }
167
168         mode->Release();
169         i++;
170     }
171
172     itermode->Release();
173
174     if (ctx->bmd_mode == bmdModeUnknown)
175         return -1;
176     if (direction == DIRECTION_IN) {
177         if (ctx->dli->DoesSupportVideoMode(ctx->bmd_mode, bmdFormat8BitYUV,
178                                            bmdVideoOutputFlagDefault,
179                                            &support, NULL) != S_OK)
180             return -1;
181     } else {
182         if (ctx->dlo->DoesSupportVideoMode(ctx->bmd_mode, bmdFormat8BitYUV,
183                                            bmdVideoOutputFlagDefault,
184                                            &support, NULL) != S_OK)
185         return -1;
186     }
187     if (support == bmdDisplayModeSupported)
188         return 0;
189
190     return -1;
191 }
192
193 int ff_decklink_set_format(AVFormatContext *avctx, decklink_direction_t direction, int num) {
194     return ff_decklink_set_format(avctx, 0, 0, 0, 0, direction, num);
195 }
196
197 int ff_decklink_list_devices(AVFormatContext *avctx)
198 {
199     IDeckLink *dl = NULL;
200     IDeckLinkIterator *iter = CreateDeckLinkIteratorInstance();
201     if (!iter) {
202         av_log(avctx, AV_LOG_ERROR, "Could not create DeckLink iterator\n");
203         return AVERROR(EIO);
204     }
205     av_log(avctx, AV_LOG_INFO, "Blackmagic DeckLink devices:\n");
206     while (iter->Next(&dl) == S_OK) {
207         const char *displayName;
208         ff_decklink_get_display_name(dl, &displayName);
209         av_log(avctx, AV_LOG_INFO, "\t'%s'\n", displayName);
210         av_free((void *) displayName);
211         dl->Release();
212     }
213     iter->Release();
214     return 0;
215 }
216
217 int ff_decklink_list_formats(AVFormatContext *avctx, decklink_direction_t direction)
218 {
219     struct decklink_cctx *cctx = (struct decklink_cctx *) avctx->priv_data;
220     struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
221     IDeckLinkDisplayModeIterator *itermode;
222     IDeckLinkDisplayMode *mode;
223     int i=0;
224     HRESULT res;
225
226     if (direction == DIRECTION_IN) {
227         res = ctx->dli->GetDisplayModeIterator (&itermode);
228     } else {
229         res = ctx->dlo->GetDisplayModeIterator (&itermode);
230     }
231
232     if (res!= S_OK) {
233             av_log(avctx, AV_LOG_ERROR, "Could not get Display Mode Iterator\n");
234             return AVERROR(EIO);
235     }
236
237     av_log(avctx, AV_LOG_INFO, "Supported formats for '%s':\n",
238                avctx->filename);
239     while (itermode->Next(&mode) == S_OK) {
240         BMDTimeValue tb_num, tb_den;
241         mode->GetFrameRate(&tb_num, &tb_den);
242         av_log(avctx, AV_LOG_INFO, "\t%d\t%ldx%ld at %d/%d fps",
243                 ++i,mode->GetWidth(), mode->GetHeight(),
244                 (int) tb_den, (int) tb_num);
245         switch (mode->GetFieldDominance()) {
246         case bmdLowerFieldFirst:
247         av_log(avctx, AV_LOG_INFO, " (interlaced, lower field first)"); break;
248         case bmdUpperFieldFirst:
249         av_log(avctx, AV_LOG_INFO, " (interlaced, upper field first)"); break;
250         }
251         av_log(avctx, AV_LOG_INFO, "\n");
252         mode->Release();
253     }
254
255     itermode->Release();
256
257     return 0;
258 }
259
260 void ff_decklink_cleanup(AVFormatContext *avctx)
261 {
262     struct decklink_cctx *cctx = (struct decklink_cctx *) avctx->priv_data;
263     struct decklink_ctx *ctx = (struct decklink_ctx *) cctx->ctx;
264
265     if (ctx->dli)
266         ctx->dli->Release();
267     if (ctx->dlo)
268         ctx->dlo->Release();
269     if (ctx->attr)
270         ctx->attr->Release();
271     if (ctx->cfg)
272         ctx->cfg->Release();
273     if (ctx->dl)
274         ctx->dl->Release();
275 }
276
277 int ff_decklink_init_device(AVFormatContext *avctx, const char* name)
278 {
279     struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
280     struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
281     IDeckLink *dl = NULL;
282     IDeckLinkIterator *iter = CreateDeckLinkIteratorInstance();
283     if (!iter) {
284         av_log(avctx, AV_LOG_ERROR, "Could not create DeckLink iterator\n");
285         return AVERROR_EXTERNAL;
286     }
287
288     while (iter->Next(&dl) == S_OK) {
289         const char *displayName;
290         ff_decklink_get_display_name(dl, &displayName);
291         if (!strcmp(name, displayName)) {
292             av_free((void *)displayName);
293             ctx->dl = dl;
294             break;
295         }
296         av_free((void *)displayName);
297         dl->Release();
298     }
299     iter->Release();
300     if (!ctx->dl)
301         return AVERROR(ENXIO);
302
303     if (ctx->dl->QueryInterface(IID_IDeckLinkConfiguration, (void **)&ctx->cfg) != S_OK) {
304         av_log(avctx, AV_LOG_ERROR, "Could not get configuration interface for '%s'\n", name);
305         ff_decklink_cleanup(avctx);
306         return AVERROR_EXTERNAL;
307     }
308
309     if (ctx->dl->QueryInterface(IID_IDeckLinkAttributes, (void **)&ctx->attr) != S_OK) {
310         av_log(avctx, AV_LOG_ERROR, "Could not get attributes interface for '%s'\n", name);
311         ff_decklink_cleanup(avctx);
312         return AVERROR_EXTERNAL;
313     }
314
315     return 0;
316 }