git.sesse.net Git - casparcg/blob - modules/decklink/decklink_api.h

   1 /*
   2 * Copyright (c) 2011 Sveriges Television AB <info@casparcg.com>
   3 *
   4 * This file is part of CasparCG (www.casparcg.com).
   5 *
   6 * CasparCG is free software: you can redistribute it and/or modify
   7 * it under the terms of the GNU General Public License as published by
   8 * the Free Software Foundation, either version 3 of the License, or
   9 * (at your option) any later version.
  10 *
  11 * CasparCG is distributed in the hope that it will be useful,
  12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 * GNU General Public License for more details.
  15 *
  16 * You should have received a copy of the GNU General Public License
  17 * along with CasparCG. If not, see <http://www.gnu.org/licenses/>.
  18 *
  19 * Author: Helge Norberg, helge.norberg@svt.se
  20 */
  21
  22 #pragma once
  23
  24 #include <common/except.h>
  25
  26 #if defined(_MSC_VER)
  27
  28 #include "interop/DeckLinkAPI.h"
  29
  30 #pragma warning(push)
  31 #pragma warning(disable : 4996)
  32
  33     #include <atlbase.h>
  34
  35     #include <atlcom.h>
  36     #include <atlhost.h>
  37
  38 #pragma warning(pop)
  39
  40 namespace caspar { namespace decklink {
  41
  42 typedef BSTR String;
  43 typedef unsigned int UINT32;
  44
  45 static void com_initialize()
  46 {
  47         ::CoInitialize(nullptr);
  48 }
  49
  50 static void com_uninitialize()
  51 {
  52         ::CoUninitialize();
  53 }
  54
  55 struct co_init
  56 {
  57     co_init(){ ::CoInitialize(nullptr); }
  58     ~co_init(){ ::CoUninitialize(); }
  59 };
  60
  61 template<typename T>
  62 using com_ptr = CComPtr<T>;
  63
  64 template<typename T>
  65 using com_iface_ptr = CComQIPtr<T>;
  66
  67 template<template<typename> class P, typename T>
  68 static P<T> wrap_raw(T* ptr, bool already_referenced = false)
  69 {
  70     if (already_referenced)
  71     {
  72         P<T> p;
  73         p.Attach(ptr);
  74         return p;
  75     }
  76     else
  77         return P<T>(ptr);
  78 }
  79
  80 static com_ptr<IDeckLinkIterator> create_iterator()
  81 {
  82     CComPtr<IDeckLinkIterator> pDecklinkIterator;
  83     if(FAILED(pDecklinkIterator.CoCreateInstance(CLSID_CDeckLinkIterator)))
  84         CASPAR_THROW_EXCEPTION(not_supported() << msg_info("Decklink drivers not found."));
  85     return pDecklinkIterator;
  86 }
  87
  88 template<typename I, typename T>
  89 static com_iface_ptr<I> iface_cast(const com_ptr<T>& ptr, bool optional = false)
  90 {
  91         com_iface_ptr<I> result = ptr;
  92
  93         if (!optional && !result)
  94                 CASPAR_THROW_EXCEPTION(not_supported() << msg_info(std::string("Could not cast from ") + typeid(T).name() + " to " + typeid(I).name() + ". This is probably due to old Decklink drivers."));
  95
  96         return result;
  97 }
  98
  99 template<typename T>
 100 T* get_raw(const CComPtr<T>& ptr)
 101 {
 102         return ptr;
 103 }
 104
 105 }}
 106
 107 #else
 108
 109 #include "linux_interop/DeckLinkAPI.h"
 110 #include "linux_interop/DeckLinkAPIConfiguration_v10_2.h"
 111 #include <memory>
 112 #include <typeinfo>
 113
 114 namespace caspar { namespace decklink {
 115
 116 typedef const char* String;
 117 typedef bool BOOL;
 118 #define TRUE true
 119 #define FALSE false
 120 typedef uint32_t UINT32;
 121
 122 static void com_initialize()
 123 {
 124 }
 125
 126 static void com_uninitialize()
 127 {
 128 }
 129
 130 struct co_init
 131 {
 132     co_init(){ }
 133     ~co_init(){ }
 134 };
 135
 136 template<typename T>
 137 using com_ptr = std::shared_ptr<T>;
 138
 139 template<typename T>
 140 using com_iface_ptr = std::shared_ptr<T>;
 141
 142 template<template<typename> class P, typename T>
 143 static P<T> wrap_raw(T* ptr, bool already_referenced = false)
 144 {
 145     if (!already_referenced && ptr)
 146         ptr->AddRef();
 147
 148         return P<T>(ptr, [](T* p)
 149         {
 150                 if (p)
 151                 {
 152                         auto remaining_refs = p->Release();
 153
 154                         //CASPAR_LOG(debug) << "Remaining references for " << typeid(p).name() << " = " << remaining_refs;
 155                 }
 156         });
 157 }
 158
 159 static com_ptr<IDeckLinkIterator> create_iterator()
 160 {
 161     IDeckLinkIterator* iterator = CreateDeckLinkIteratorInstance();
 162
 163     if (iterator == nullptr)
 164         CASPAR_THROW_EXCEPTION(not_supported() << msg_info("Decklink drivers not found."));
 165
 166         return wrap_raw<com_ptr>(iterator, true);
 167 }
 168
 169 template<typename T>    static REFIID iface_id() { return T::REFID; }
 170 template<>              REFIID iface_id<IDeckLink>() { return IID_IDeckLink; }
 171 template<>              REFIID iface_id<IDeckLinkOutput>() { return IID_IDeckLinkOutput; }
 172 template<>              REFIID iface_id<IDeckLinkAPIInformation>() { return IID_IDeckLinkAPIInformation; }
 173 template<>              REFIID iface_id<IDeckLinkConfiguration>() { return IID_IDeckLinkConfiguration; }
 174 template<>              REFIID iface_id<IDeckLinkConfiguration_v10_2>() { return IID_IDeckLinkConfiguration_v10_2; }
 175 template<>              REFIID iface_id<IDeckLinkKeyer>() { return IID_IDeckLinkKeyer; }
 176 template<>              REFIID iface_id<IDeckLinkAttributes>() { return IID_IDeckLinkAttributes; }
 177 template<>              REFIID iface_id<IDeckLinkInput>() { return IID_IDeckLinkInput; }
 178
 179 template<typename I, typename T>
 180 static com_iface_ptr<I> iface_cast(com_ptr<T> ptr, bool optional = false)
 181 {
 182     I* iface;
 183     ptr->QueryInterface(iface_id<I>(), reinterpret_cast<void**>(&iface));
 184
 185         return wrap_raw<com_iface_ptr>(iface, true);
 186 }
 187
 188 template<typename T>
 189 T* get_raw(const std::shared_ptr<T>& ptr)
 190 {
 191         return ptr.get();
 192 }
 193
 194 }}
 195
 196 #endif