git.sesse.net Git - casparcg/blob - core/consumer/decklink/DecklinkVideoConsumer.cpp

   1 /*\r
   2 * copyright (c) 2010 Sveriges Television AB <info@casparcg.com>\r
   3 *\r
   4 *  This file is part of CasparCG.\r
   5 *\r
   6 *    CasparCG is free software: you can redistribute it and/or modify\r
   7 *    it under the terms of the GNU General Public License as published by\r
   8 *    the Free Software Foundation, either version 3 of the License, or\r
   9 *    (at your option) any later version.\r
  10 *\r
  11 *    CasparCG is distributed in the hope that it will be useful,\r
  12 *    but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  13 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  14 *    GNU General Public License for more details.\r
  15 \r
  16 *    You should have received a copy of the GNU General Public License\r
  17 *    along with CasparCG.  If not, see <http://www.gnu.org/licenses/>.\r
  18 *\r
  19 */\r
  20  \r
  21 #include "../../stdafx.h"\r
  22 \r
  23 #if defined(_MSC_VER)\r
  24 #pragma warning (push, 1) // TODO: Legacy code, just disable warnings\r
  25 #pragma warning (disable : 4244)\r
  26 #endif\r
  27 \r
  28 #include "DecklinkVideoConsumer.h"\r
  29 #include "DeckLinkAPI_h.h"\r
  30 \r
  31 #include "../../frame/frame_format.h"\r
  32 #include "../../../common/image/image.h"\r
  33 \r
  34 #include "../../renderer/render_device.h"\r
  35 \r
  36 #include <tbb/concurrent_queue.h>\r
  37 #include <boost/thread.hpp>\r
  38 \r
  39 #pragma warning(push)\r
  40 #pragma warning(disable : 4996)\r
  41 \r
  42         #include <atlbase.h>\r
  43 \r
  44         #include <atlcom.h>\r
  45         #include <atlhost.h>\r
  46 \r
  47 #pragma warning(push)\r
  48 \r
  49 namespace caspar{ namespace decklink{\r
  50 \r
  51 struct DecklinkVideoConsumer::Implementation : public IDeckLinkVideoOutputCallback\r
  52 {\r
  53         struct DecklinkFrameManager;\r
  54         struct DecklinkVideoFrame\r
  55         {\r
  56                 explicit DecklinkVideoFrame(DecklinkFrameManager* pFactory)\r
  57                 {\r
  58                         IDeckLinkMutableVideoFrame* frame = NULL;\r
  59                         const caspar::frame_format_desc& format_desc = pFactory->pConsumerImpl_->get_frame_format_desc();\r
  60                         if(pFactory->pConsumerImpl_->pDecklinkOutput_->CreateVideoFrame(format_desc.width, format_desc.height, format_desc.size/format_desc.height, bmdFormat8BitBGRA, bmdFrameFlagDefault, &frame) != S_OK) \r
  61                         {\r
  62                                 throw std::exception("DECKLINK: Failed to create frame");\r
  63                         }\r
  64                         pDecklinkFrame_ = frame;\r
  65                         frame->Release();\r
  66 \r
  67                         if(pDecklinkFrame_->GetBytes((void**)&pBytes_) != S_OK)\r
  68                                 throw std::exception("DECKLINK: Failed to get bytes to frame");\r
  69                 }\r
  70 \r
  71                 unsigned char* data() \r
  72                 {\r
  73                         return pBytes_;\r
  74                 }\r
  75                 \r
  76                 size_t width() const { return 0; }\r
  77                 size_t height() const { return 0; }\r
  78 \r
  79                 bool valid() const \r
  80                 {\r
  81                         return true;\r
  82                 }\r
  83 \r
  84                 unsigned int size() const \r
  85                 {\r
  86                         return pDecklinkFrame_->GetRowBytes() * pDecklinkFrame_->GetHeight();\r
  87                 }\r
  88 \r
  89                 IDeckLinkMutableVideoFrame*  meta_data() const \r
  90                 {\r
  91                         return pDecklinkFrame_;\r
  92                 }\r
  93 \r
  94                 void* tag() const\r
  95                 {\r
  96                         return pFactory_;\r
  97                 }\r
  98 \r
  99                 DecklinkFrameManager* pFactory_;\r
 100                 CComPtr<IDeckLinkMutableVideoFrame> pDecklinkFrame_;\r
 101                 unsigned char* pBytes_;\r
 102         };\r
 103 \r
 104         struct DecklinkPlaybackStrategy\r
 105         {\r
 106                 explicit DecklinkPlaybackStrategy(Implementation* pConsumerImpl) : pConsumerImpl_(pConsumerImpl), currentReservedFrameIndex_(0), totalFramesScheduled_(0)\r
 107                 {\r
 108                         for(int i = 0; i<4; ++i) \r
 109                         {\r
 110                                 reservedFrames_.push_back(pConsumerImpl_->pFrameManager_->CreateReservedFrame());\r
 111                         }\r
 112                 }\r
 113                 \r
 114                 std::shared_ptr<DecklinkVideoFrame> GetReservedFrame()\r
 115                 {\r
 116                         std::shared_ptr<DecklinkVideoFrame> pResult;\r
 117                         if(reservedFrames_.size() > currentReservedFrameIndex_)\r
 118                         {\r
 119                                 pResult = reservedFrames_[currentReservedFrameIndex_];\r
 120                                 currentReservedFrameIndex_ = (currentReservedFrameIndex_+1) & 3;\r
 121                         }\r
 122                         return pResult;\r
 123                 }\r
 124 \r
 125                 void DisplayFrame(const gpu_frame_ptr& frame)\r
 126                 {\r
 127                         if(frame != NULL) \r
 128                         {\r
 129                                 std::shared_ptr<DecklinkVideoFrame> pTempFrame = GetReservedFrame();\r
 130                                 if(pTempFrame && frame->size() == pTempFrame->size())\r
 131                                 {\r
 132                                         common::image::copy(pTempFrame->data(), frame->data(), pTempFrame->size());\r
 133                                         DoRender(pTempFrame);\r
 134                                 }\r
 135                                 else\r
 136                                         CASPAR_LOG(error) << "DECKLINK: Failed to get reserved frame";                          \r
 137                         }\r
 138                         else \r
 139                         {\r
 140                                 CASPAR_LOG(error) << "DECKLINK: Tried to render frame with no data";\r
 141                         }\r
 142                 }\r
 143                 void DoRender(const std::shared_ptr<DecklinkVideoFrame>& frame)\r
 144                 {\r
 145                         static DWORD lastTime = 0;\r
 146                         static bool bDoLog = true;\r
 147 \r
 148                         if(pConsumerImpl_->pDecklinkOutput_->DisplayVideoFrameSync(reinterpret_cast<IDeckLinkMutableVideoFrame*>(frame->meta_data())) != S_OK) \r
 149                         {\r
 150                                 if(bDoLog)\r
 151                                 {\r
 152                                         CASPAR_LOG(error) << "DECKLINK: Failed to render frame";\r
 153                                         bDoLog = false;\r
 154                                 }\r
 155                         }\r
 156                         else \r
 157                         {\r
 158                                 bDoLog = true;\r
 159                         }\r
 160 //                      lastFrameID_ = frame->ID();\r
 161                 }\r
 162 \r
 163                 int totalFramesScheduled_;\r
 164                 std::vector<std::shared_ptr<DecklinkVideoFrame> > reservedFrames_;\r
 165                 unsigned int currentReservedFrameIndex_;\r
 166                 Implementation* pConsumerImpl_;\r
 167         };\r
 168         friend struct DecklinkPlaybackStrategy;\r
 169 \r
 170         struct DecklinkFrameManager\r
 171         {\r
 172                 explicit DecklinkFrameManager(Implementation* pConsumerImpl) : pConsumerImpl_(pConsumerImpl)\r
 173                 {\r
 174                 }\r
 175                 \r
 176                 std::shared_ptr<DecklinkVideoFrame>  CreateReservedFrame() {\r
 177                         return std::make_shared<DecklinkVideoFrame>(this);\r
 178                 }\r
 179 \r
 180                 const caspar::frame_format_desc& get_frame_format_desc() const {\r
 181                         return pConsumerImpl_->get_frame_format_desc();\r
 182                 }\r
 183 \r
 184                 Implementation* pConsumerImpl_;\r
 185         };\r
 186 \r
 187         typedef std::tr1::shared_ptr<DecklinkFrameManager> DecklinkFrameManagerPtr;\r
 188 \r
 189         bool internalKey_;\r
 190         CComPtr<IDeckLink> pDecklink_;\r
 191         CComQIPtr<IDeckLinkOutput> pDecklinkOutput_;\r
 192         CComQIPtr<IDeckLinkKeyer> pDecklinkKeyer_;\r
 193 \r
 194         std::shared_ptr<DecklinkPlaybackStrategy> pPlayback_;\r
 195         DecklinkFrameManagerPtr pFrameManager_;\r
 196         frame_format currentFormat_;\r
 197         frame_format_desc format_desc_;\r
 198 \r
 199         std::exception_ptr pException_;\r
 200         boost::thread thread_;\r
 201         tbb::concurrent_bounded_queue<gpu_frame_ptr> frameBuffer_;\r
 202 \r
 203 //      IDeckLinkMutableVideoFrame* pNextFrame_;\r
 204 \r
 205         explicit Implementation(const caspar::frame_format_desc& format_desc, bool internalKey) \r
 206                 : format_desc_(format_desc), currentFormat_(frame_format::pal), internalKey_(internalKey)\r
 207         {\r
 208         \r
 209                 CComPtr<IDeckLinkIterator> pDecklinkIterator;\r
 210                 HRESULT result = pDecklinkIterator.CoCreateInstance(CLSID_CDeckLinkIterator);\r
 211                 if(FAILED(result))\r
 212                         BOOST_THROW_EXCEPTION(caspar_exception() << msg_info("No Decklink drivers installed"));\r
 213 \r
 214                 CComPtr<IDeckLink> pDecklink;\r
 215                 IDeckLink* pTempDecklink = NULL;\r
 216                 while(pDecklinkIterator->Next(&pTempDecklink) == S_OK) \r
 217                 {\r
 218                         if(pDecklink == NULL)\r
 219                                 pDecklink = pTempDecklink;\r
 220 \r
 221                         if(pTempDecklink)\r
 222                                 pTempDecklink->Release();\r
 223                         pTempDecklink = NULL;\r
 224                 }\r
 225 \r
 226                 if(pDecklink == nullptr)\r
 227                         BOOST_THROW_EXCEPTION(caspar_exception() << msg_info("No Decklink card found"));\r
 228 \r
 229                 if(!SetupDevice())\r
 230                         BOOST_THROW_EXCEPTION(caspar_exception() << msg_info("Failed to initialize decklink consumer."));\r
 231                 \r
 232                 pDecklink_ = pDecklink;\r
 233 \r
 234                 frameBuffer_.set_capacity(1),\r
 235                 thread_ = boost::thread([=]{Run();});\r
 236         }\r
 237 \r
 238         ~Implementation()\r
 239         {\r
 240                 frameBuffer_.push(nullptr);\r
 241                 thread_.join();\r
 242                 ReleaseDevice();\r
 243         }\r
 244         \r
 245         void DisplayFrame(const gpu_frame_ptr& frame)\r
 246         {\r
 247                 if(frame == nullptr)\r
 248                         return;         \r
 249 \r
 250                 if(pException_ != nullptr)\r
 251                         std::rethrow_exception(pException_);\r
 252 \r
 253                 frameBuffer_.push(frame);\r
 254         }\r
 255 \r
 256         void Run()\r
 257         {                               \r
 258                 auto period = boost::posix_time::microseconds(get_frame_format_period(format_desc_)*1000000);\r
 259                 auto time = boost::posix_time::microsec_clock::local_time();\r
 260                 while(true)\r
 261                 {\r
 262                         try\r
 263                         {       \r
 264                                 gpu_frame_ptr frame;\r
 265                                 frameBuffer_.pop(frame);\r
 266                                 if(frame == nullptr)\r
 267                                         return;\r
 268 \r
 269                                 auto remaining = period - (boost::posix_time::microsec_clock::local_time() - time);\r
 270                                 if(remaining > boost::posix_time::microseconds(5000))\r
 271                                         boost::this_thread::sleep(remaining - boost::posix_time::microseconds(5000));\r
 272                                 time = boost::posix_time::microsec_clock::local_time();\r
 273 \r
 274                                 pPlayback_->DisplayFrame(frame);\r
 275                         }\r
 276                         catch(...)\r
 277                         {\r
 278                                 pException_ = std::current_exception();\r
 279                         }\r
 280                 }\r
 281         }\r
 282 \r
 283         bool SetupDevice()\r
 284         {\r
 285                 if(!pDecklink_)\r
 286                         return false;\r
 287 \r
 288                 BSTR pModelName;\r
 289                 pDecklink_->GetModelName(&pModelName);\r
 290                 if(pModelName != NULL)\r
 291                         CASPAR_LOG(info) << "DECKLINK: Modelname: " << pModelName;\r
 292 \r
 293                 pDecklinkOutput_ = pDecklink_;\r
 294                 if(pDecklinkOutput_ == NULL) {\r
 295                         CASPAR_LOG(info) << "DECKLINK: Failed to get IDecklinkOutput interface";\r
 296                         return false;\r
 297                 }\r
 298 \r
 299                 unsigned long decklinkVideoFormat = GetDecklinkVideoFormat(format_desc_.format);\r
 300                 if(decklinkVideoFormat == ULONG_MAX) {\r
 301                         CASPAR_LOG(error) << "DECKLINK: Card does not support requested videoformat: " << format_desc_.name;\r
 302                         return false;\r
 303                 }\r
 304                 \r
 305                 currentFormat_ = format_desc_.format;\r
 306 \r
 307                 BMDDisplayModeSupport displayModeSupport;\r
 308                 if(FAILED(pDecklinkOutput_->DoesSupportVideoMode((BMDDisplayMode)decklinkVideoFormat, bmdFormat8BitBGRA, &displayModeSupport))) {\r
 309                         CASPAR_LOG(error) << "DECKLINK: Card does not support requested videoformat";\r
 310                         return false;\r
 311                 }\r
 312 \r
 313                 pDecklinkOutput_->DisableAudioOutput();\r
 314                 if(FAILED(pDecklinkOutput_->EnableVideoOutput((BMDDisplayMode)decklinkVideoFormat, bmdVideoOutputFlagDefault))) {\r
 315                         CASPAR_LOG(error) << "DECKLINK: Could not enable video output";\r
 316                         return false;\r
 317                 }\r
 318 \r
 319                 pFrameManager_.reset(new DecklinkFrameManager(this));\r
 320 \r
 321                 if(internalKey_) {\r
 322                         pDecklinkKeyer_ = pDecklink_;\r
 323                         if(pDecklinkKeyer_) {\r
 324                                 bool bSuccess = true;\r
 325                                 if(FAILED(pDecklinkKeyer_->Enable(FALSE))) {\r
 326                                         CASPAR_LOG(error) << "DECKLINK: Failed to enable internal keyer";\r
 327                                         bSuccess = false;\r
 328                                 }\r
 329                                 if(FAILED(pDecklinkKeyer_->SetLevel(255))) {\r
 330                                         CASPAR_LOG(error) << "DECKLINK: Keyer - Failed to set blend-level to max";\r
 331                                         bSuccess = false;\r
 332                                 }\r
 333 \r
 334                                 if(bSuccess)\r
 335                                         CASPAR_LOG(info) << "DECKLINK: Successfully configured internal keyer";\r
 336                         }\r
 337                         else {\r
 338                                 CASPAR_LOG(error) << "DECKLINK: Failed to get keyer-interface";\r
 339                         }\r
 340                 }\r
 341 \r
 342                 pPlayback_ = std::make_shared<DecklinkPlaybackStrategy>(this);\r
 343 \r
 344                 CASPAR_LOG(info) << "DECKLINK: Successfully initialized decklink for " << format_desc_.name;\r
 345                 return true;\r
 346         }\r
 347 \r
 348         bool ReleaseDevice()\r
 349         {\r
 350                 pPlayback_.reset();\r
 351 \r
 352                 if(pDecklinkKeyer_) {\r
 353                         pDecklinkKeyer_.Release();\r
 354                 }\r
 355 \r
 356                 if(pDecklinkOutput_) {\r
 357                         BOOL bIsRunning = FALSE;\r
 358                         pDecklinkOutput_->IsScheduledPlaybackRunning(&bIsRunning);\r
 359                         if(bIsRunning)\r
 360                                 pDecklinkOutput_->StopScheduledPlayback(0, NULL, 0);\r
 361 \r
 362                         pDecklinkOutput_->DisableVideoOutput();\r
 363                 }\r
 364 \r
 365                 return true;\r
 366         }\r
 367 \r
 368         //void DoScheduleNextFrame() {\r
 369         //      static int frame = 0;\r
 370         //      static bool bLog = true;\r
 371         //      if(pDecklinkOutput_->ScheduleVideoFrame(pNextFrame_, frame++, 1, 25) != S_OK) {\r
 372         //              if(bLog) {\r
 373         //                      LOG << TEXT("DECKLINK: Failed to display frame");\r
 374         //                      bLog = false;\r
 375         //              }\r
 376         //      }\r
 377         //      else {\r
 378         //              if(((frame-1) % 25) == 0)\r
 379         //                      LOG << TEXT("DECKLINK: Scheduled frame ") << (frame-1);\r
 380         //              bLog = true;\r
 381         //      }\r
 382         //}\r
 383 \r
 384         // IUnknown needs o a dummy implementation\r
 385         virtual HRESULT STDMETHODCALLTYPE       QueryInterface(REFIID iid, LPVOID *ppv) \r
 386         {\r
 387                 if(ppv != NULL) {\r
 388                         if(iid == IID_IUnknown) {\r
 389                                 (*ppv) = this;\r
 390                                 return S_OK;\r
 391                         }\r
 392                         if(iid == IID_IDeckLinkVideoOutputCallback_v7_1) {\r
 393                                 (*ppv) = (IDeckLinkVideoOutputCallback_v7_1*)this;\r
 394                                 return S_OK;\r
 395                         }\r
 396                         if(iid == IID_IDeckLinkVideoOutputCallback) {\r
 397                                 (*ppv) = (IDeckLinkVideoOutputCallback*)this;\r
 398                                 return S_OK;\r
 399                         }\r
 400                 }\r
 401                 return E_NOINTERFACE;\r
 402         }\r
 403         virtual ULONG STDMETHODCALLTYPE         AddRef() {return 1;}\r
 404         virtual ULONG STDMETHODCALLTYPE         Release() {return 1;}\r
 405 \r
 406         virtual HRESULT STDMETHODCALLTYPE ScheduledFrameCompleted(IDeckLinkVideoFrame* completedFrame, BMDOutputFrameCompletionResult result) {\r
 407                 //DoScheduleNextFrame();\r
 408                 return S_OK;\r
 409         }\r
 410 \r
 411         virtual HRESULT STDMETHODCALLTYPE ScheduledPlaybackHasStopped() \r
 412         {\r
 413                 return S_OK;\r
 414         }\r
 415 \r
 416         const caspar::frame_format_desc& get_frame_format_desc() const \r
 417         {\r
 418                 return frame_format_desc::format_descs[currentFormat_];\r
 419         }\r
 420 \r
 421         unsigned long GetDecklinkVideoFormat(frame_format fmt) \r
 422         {\r
 423                 switch(fmt)\r
 424                 {\r
 425                 case frame_format::pal:                 return bmdModePAL;\r
 426                 case frame_format::ntsc:                return bmdModeNTSC;\r
 427                 case frame_format::x576p2500:   return ULONG_MAX;       //not supported\r
 428                 case frame_format::x720p5000:   return bmdModeHD720p50;\r
 429                 case frame_format::x720p5994:   return bmdModeHD720p5994;\r
 430                 case frame_format::x720p6000:   return bmdModeHD720p60;\r
 431                 case frame_format::x1080p2397:  return bmdModeHD1080p2398;\r
 432                 case frame_format::x1080p2400:  return bmdModeHD1080p24;\r
 433                 case frame_format::x1080i5000:  return bmdModeHD1080i50;\r
 434                 case frame_format::x1080i5994:  return bmdModeHD1080i5994;\r
 435                 case frame_format::x1080i6000:  return bmdModeHD1080i6000;\r
 436                 case frame_format::x1080p2500:  return bmdModeHD1080p25;\r
 437                 case frame_format::x1080p2997:  return bmdModeHD1080p2997;\r
 438                 case frame_format::x1080p3000:  return bmdModeHD1080p30;\r
 439                 default:                                                return ULONG_MAX;\r
 440                 }\r
 441         }\r
 442 };\r
 443 \r
 444 DecklinkVideoConsumer::DecklinkVideoConsumer(const caspar::frame_format_desc& format_desc, bool internalKey) : pImpl_(new Implementation(format_desc, internalKey))\r
 445 {}\r
 446 \r
 447 void DecklinkVideoConsumer::display(const gpu_frame_ptr& frame)\r
 448 {\r
 449         pImpl_->DisplayFrame(frame);\r
 450 }\r
 451 \r
 452 const frame_format_desc& DecklinkVideoConsumer::get_frame_format_desc() const\r
 453 {\r
 454         return pImpl_->format_desc_;\r
 455 }\r
 456         \r
 457 }       //namespace decklink\r
 458 }       //namespace caspar