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.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 long 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 = 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(caspar_exception() << 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(com_ptr<T> ptr)
  90 {
  91     return com_iface_ptr<I>(ptr);
  92 }
  93
  94 template<typename T>
  95 T* get_raw(const CComPtr<T>& ptr)
  96 {
  97         return ptr;
  98 }
  99
 100 }}
 101
 102 #else
 103
 104 #include "linux_interop/DeckLinkAPI.h"
 105 #include <memory>
 106 #include <typeinfo>
 107
 108 namespace caspar { namespace decklink {
 109
 110 typedef const char* String;
 111 typedef bool BOOL;
 112 #define TRUE true
 113 #define FALSE false
 114 typedef uint32_t UINT32;
 115
 116 static void com_initialize()
 117 {
 118 }
 119
 120 static void com_uninitialize()
 121 {
 122 }
 123
 124 struct co_init
 125 {
 126     co_init(){ }
 127     ~co_init(){ }
 128 };
 129
 130 template<typename T>
 131 using com_ptr = std::shared_ptr<T>;
 132
 133 template<typename T>
 134 using com_iface_ptr = std::shared_ptr<T>;
 135
 136 template<template<typename> class P, typename T>
 137 static P<T> wrap_raw(T* ptr, bool already_referenced = false)
 138 {
 139     if (!already_referenced && ptr)
 140         ptr->AddRef();
 141
 142         return P<T>(ptr, [](T* p)
 143         {
 144                 if (p)
 145                 {
 146                         auto remaining_refs = p->Release();
 147
 148                         //CASPAR_LOG(debug) << "Remaining references for " << typeid(p).name() << " = " << remaining_refs;
 149                 }
 150         });
 151 }
 152
 153 static com_ptr<IDeckLinkIterator> create_iterator()
 154 {
 155     IDeckLinkIterator* iterator = CreateDeckLinkIteratorInstance();
 156
 157     if (iterator == nullptr)
 158         CASPAR_THROW_EXCEPTION(caspar_exception() << msg_info("Decklink drivers not found."));
 159
 160         return wrap_raw<com_ptr>(iterator, true);
 161 }
 162
 163 template<typename T>    static REFIID iface_id() { return T::REFID; }
 164 template<>              REFIID iface_id<IDeckLink>() { return IID_IDeckLink; }
 165 template<>              REFIID iface_id<IDeckLinkOutput>() { return IID_IDeckLinkOutput; }
 166 template<>              REFIID iface_id<IDeckLinkAPIInformation>() { return IID_IDeckLinkAPIInformation; }
 167 template<>              REFIID iface_id<IDeckLinkConfiguration>() { return IID_IDeckLinkConfiguration; }
 168 template<>              REFIID iface_id<IDeckLinkKeyer>() { return IID_IDeckLinkKeyer; }
 169 template<>              REFIID iface_id<IDeckLinkAttributes>() { return IID_IDeckLinkAttributes; }
 170 template<>              REFIID iface_id<IDeckLinkInput>() { return IID_IDeckLinkInput; }
 171
 172 template<typename I, typename T>
 173 static com_iface_ptr<I> iface_cast(com_ptr<T> ptr)
 174 {
 175     I* iface;
 176     ptr->QueryInterface(iface_id<I>(), reinterpret_cast<void**>(&iface));
 177
 178         return wrap_raw<com_iface_ptr>(iface, true);
 179 }
 180
 181 template<typename T>
 182 T* get_raw(const std::shared_ptr<T>& ptr)
 183 {
 184         return ptr.get();
 185 }
 186
 187 }}
 188
 189 #endif