git.sesse.net Git - ffmpeg/blob - 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 #else
  74 #define DECKLINK_STR    const char *
  75 #define DECKLINK_STRDUP av_strdup
  76 /* free() is needed for a string returned by the DeckLink SDL. */
  77 #define DECKLINK_FREE(s) free((void *) s)
  78 #endif
  79
  80 HRESULT ff_decklink_get_display_name(IDeckLink *This, const char **displayName)
  81 {
  82     DECKLINK_STR tmpDisplayName;
  83     HRESULT hr = This->GetDisplayName(&tmpDisplayName);
  84     if (hr != S_OK)
  85         return hr;
  86     *displayName = DECKLINK_STRDUP(tmpDisplayName);
  87     DECKLINK_FREE(tmpDisplayName);
  88     return hr;
  89 }
  90
  91 int ff_decklink_set_format(AVFormatContext *avctx,
  92                                int width, int height,
  93                                int tb_num, int tb_den,
  94                                decklink_direction_t direction, int num)
  95 {
  96     struct decklink_cctx *cctx = (struct decklink_cctx *) avctx->priv_data;
  97     struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
  98     BMDDisplayModeSupport support;
  99     IDeckLinkDisplayModeIterator *itermode;
 100     IDeckLinkDisplayMode *mode;
 101     int i = 1;
 102     HRESULT res;
 103
 104     if (direction == DIRECTION_IN) {
 105         res = ctx->dli->GetDisplayModeIterator (&itermode);
 106     } else {
 107         res = ctx->dlo->GetDisplayModeIterator (&itermode);
 108     }
 109
 110     if (res!= S_OK) {
 111             av_log(avctx, AV_LOG_ERROR, "Could not get Display Mode Iterator\n");
 112             return AVERROR(EIO);
 113     }
 114
 115
 116     if (tb_num == 1) {
 117         tb_num *= 1000;
 118         tb_den *= 1000;
 119     }
 120     ctx->bmd_mode = bmdModeUnknown;
 121     while ((ctx->bmd_mode == bmdModeUnknown) && itermode->Next(&mode) == S_OK) {
 122         BMDTimeValue bmd_tb_num, bmd_tb_den;
 123         int bmd_width  = mode->GetWidth();
 124         int bmd_height = mode->GetHeight();
 125
 126         mode->GetFrameRate(&bmd_tb_num, &bmd_tb_den);
 127
 128         if ((bmd_width == width && bmd_height == height &&
 129             bmd_tb_num == tb_num && bmd_tb_den == tb_den) || i == num) {
 130             ctx->bmd_mode   = mode->GetDisplayMode();
 131             ctx->bmd_width  = bmd_width;
 132             ctx->bmd_height = bmd_height;
 133             ctx->bmd_tb_den = bmd_tb_den;
 134             ctx->bmd_tb_num = bmd_tb_num;
 135             ctx->bmd_field_dominance = mode->GetFieldDominance();
 136             av_log(avctx, AV_LOG_INFO, "Found Decklink mode %d x %d with rate %.2f%s\n",
 137                 bmd_width, bmd_height, (float)bmd_tb_den/(float)bmd_tb_num,
 138                 (ctx->bmd_field_dominance==bmdLowerFieldFirst || ctx->bmd_field_dominance==bmdUpperFieldFirst)?"(i)":"");
 139         }
 140
 141         mode->Release();
 142         i++;
 143     }
 144
 145     itermode->Release();
 146
 147     if (ctx->bmd_mode == bmdModeUnknown)
 148         return -1;
 149     if (direction == DIRECTION_IN) {
 150         if (ctx->dli->DoesSupportVideoMode(ctx->bmd_mode, bmdFormat8BitYUV,
 151                                            bmdVideoOutputFlagDefault,
 152                                            &support, NULL) != S_OK)
 153             return -1;
 154     } else {
 155         if (ctx->dlo->DoesSupportVideoMode(ctx->bmd_mode, bmdFormat8BitYUV,
 156                                            bmdVideoOutputFlagDefault,
 157                                            &support, NULL) != S_OK)
 158         return -1;
 159     }
 160     if (support == bmdDisplayModeSupported)
 161         return 0;
 162
 163     return -1;
 164 }
 165
 166 int ff_decklink_set_format(AVFormatContext *avctx, decklink_direction_t direction, int num) {
 167     return ff_decklink_set_format(avctx, 0, 0, 0, 0, direction, num);
 168 }
 169
 170 int ff_decklink_list_devices(AVFormatContext *avctx)
 171 {
 172     IDeckLink *dl = NULL;
 173     IDeckLinkIterator *iter = CreateDeckLinkIteratorInstance();
 174     if (!iter) {
 175         av_log(avctx, AV_LOG_ERROR, "Could not create DeckLink iterator\n");
 176         return AVERROR(EIO);
 177     }
 178     av_log(avctx, AV_LOG_INFO, "Blackmagic DeckLink devices:\n");
 179     while (iter->Next(&dl) == S_OK) {
 180         const char *displayName;
 181         ff_decklink_get_display_name(dl, &displayName);
 182         av_log(avctx, AV_LOG_INFO, "\t'%s'\n", displayName);
 183         av_free((void *) displayName);
 184         dl->Release();
 185     }
 186     iter->Release();
 187     return 0;
 188 }
 189
 190 int ff_decklink_list_formats(AVFormatContext *avctx, decklink_direction_t direction)
 191 {
 192     struct decklink_cctx *cctx = (struct decklink_cctx *) avctx->priv_data;
 193     struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
 194     IDeckLinkDisplayModeIterator *itermode;
 195     IDeckLinkDisplayMode *mode;
 196     int i=0;
 197     HRESULT res;
 198
 199     if (direction == DIRECTION_IN) {
 200         res = ctx->dli->GetDisplayModeIterator (&itermode);
 201     } else {
 202         res = ctx->dlo->GetDisplayModeIterator (&itermode);
 203     }
 204
 205     if (res!= S_OK) {
 206             av_log(avctx, AV_LOG_ERROR, "Could not get Display Mode Iterator\n");
 207             return AVERROR(EIO);
 208     }
 209
 210     av_log(avctx, AV_LOG_INFO, "Supported formats for '%s':\n",
 211                avctx->filename);
 212     while (itermode->Next(&mode) == S_OK) {
 213         BMDTimeValue tb_num, tb_den;
 214         mode->GetFrameRate(&tb_num, &tb_den);
 215         av_log(avctx, AV_LOG_INFO, "\t%d\t%ldx%ld at %d/%d fps",
 216                 ++i,mode->GetWidth(), mode->GetHeight(),
 217                 (int) tb_den, (int) tb_num);
 218         switch (mode->GetFieldDominance()) {
 219         case bmdLowerFieldFirst:
 220         av_log(avctx, AV_LOG_INFO, " (interlaced, lower field first)"); break;
 221         case bmdUpperFieldFirst:
 222         av_log(avctx, AV_LOG_INFO, " (interlaced, upper field first)"); break;
 223         }
 224         av_log(avctx, AV_LOG_INFO, "\n");
 225         mode->Release();
 226     }
 227
 228     itermode->Release();
 229
 230     return 0;
 231 }