git.sesse.net Git - kdenlive/blob - src/blackmagic/devices.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2007 by Jean-Baptiste Mardelle (jb@kdenlive.org)        *
   3  *                                                                         *
   4  *   This program is free software; you can redistribute it and/or modify  *
   5  *   it under the terms of the GNU General Public License as published by  *
   6  *   the Free Software Foundation; either version 2 of the License, or     *
   7  *   (at your option) any later version.                                   *
   8  *                                                                         *
   9  *   This program is distributed in the hope that it will be useful,       *
  10  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  11  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  12  *   GNU General Public License for more details.                          *
  13  *                                                                         *
  14  *   You should have received a copy of the GNU General Public License     *
  15  *   along with this program; if not, write to the                         *
  16  *   Free Software Foundation, Inc.,                                       *
  17  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA          *
  18  ***************************************************************************/
  19
  20
  21 #include "devices.h"
  22
  23 #include <KDebug>
  24 #include <KLocale>
  25
  26
  27 BMInterface::BMInterface()
  28 {
  29 }
  30
  31 //static
  32 bool BMInterface::getBlackMagicDeviceList(KComboBox *devicelist, KComboBox *modelist)
  33 {
  34     IDeckLinkIterator* deckLinkIterator;
  35     IDeckLink* deckLink;
  36     int numDevices = 0;
  37     HRESULT result;
  38     bool found = false;
  39
  40     // Create an IDeckLinkIterator object to enumerate all DeckLink cards in the system
  41     deckLinkIterator = CreateDeckLinkIteratorInstance();
  42     if(deckLinkIterator == NULL) {
  43         kDebug() << "A DeckLink iterator could not be created.  The DeckLink drivers may not be installed.";
  44         return found;
  45     }
  46
  47     // Enumerate all cards in this system
  48     while(deckLinkIterator->Next(&deckLink) == S_OK) {
  49         char *      deviceNameString = NULL;
  50
  51         // Increment the total number of DeckLink cards found
  52         numDevices++;
  53         //if (numDevices > 1)
  54         kDebug() << "// FOUND a BM device\n\n+++++++++++++++++++++++++++++++++++++";
  55
  56         // *** Print the model name of the DeckLink card
  57         result = deckLink->GetModelName((const char **) &deviceNameString);
  58         if(result == S_OK) {
  59             QString deviceName(deviceNameString);
  60             free(deviceNameString);
  61
  62             IDeckLinkInput*                 deckLinkInput = NULL;
  63             IDeckLinkDisplayModeIterator*       displayModeIterator = NULL;
  64             IDeckLinkDisplayMode*               displayMode = NULL;
  65             HRESULT                             result;
  66
  67             // Query the DeckLink for its configuration interface
  68             result = deckLink->QueryInterface(IID_IDeckLinkInput, (void**)&deckLinkInput);
  69             if(result != S_OK) {
  70                 kDebug() << "Could not obtain the IDeckLinkInput interface - result = " << result;
  71                 return found;
  72             }
  73
  74             // Obtain an IDeckLinkDisplayModeIterator to enumerate the display modes supported on output
  75             result = deckLinkInput->GetDisplayModeIterator(&displayModeIterator);
  76             if(result != S_OK) {
  77                 kDebug() << "Could not obtain the video input display mode iterator - result = " << result;
  78                 return found;
  79             }
  80             QStringList availableModes;
  81             // List all supported output display modes
  82             while(displayModeIterator->Next(&displayMode) == S_OK) {
  83                 char *          displayModeString = NULL;
  84
  85                 result = displayMode->GetName((const char **) &displayModeString);
  86                 if(result == S_OK) {
  87                     //char                  modeName[64];
  88                     int                     modeWidth;
  89                     int                     modeHeight;
  90                     BMDTimeValue            frameRateDuration;
  91                     BMDTimeScale            frameRateScale;
  92                     //int                       pixelFormatIndex = 0; // index into the gKnownPixelFormats / gKnownFormatNames arrays
  93                     //BMDDisplayModeSupport displayModeSupport;
  94
  95
  96                     // Obtain the display mode's properties
  97                     modeWidth = displayMode->GetWidth();
  98                     modeHeight = displayMode->GetHeight();
  99                     displayMode->GetFrameRate(&frameRateDuration, &frameRateScale);
 100                     QString description = QString(displayModeString) + " (" + QString::number(modeWidth) + "x" + QString::number(modeHeight) + " - " + QString::number((double)frameRateScale / (double)frameRateDuration) + i18n("fps") + ")";
 101                     availableModes << description;
 102                     //modelist->addItem(description);
 103                     //printf(" %-20s \t %d x %d \t %7g FPS\t", displayModeString, modeWidth, modeHeight, (double)frameRateScale / (double)frameRateDuration);
 104
 105                     // Print the supported pixel formats for this display mode
 106                     /*while ((gKnownPixelFormats[pixelFormatIndex] != 0) && (gKnownPixelFormatNames[pixelFormatIndex] != NULL))
 107                     {
 108                         if ((deckLinkOutput->DoesSupportVideoMode(displayMode->GetDisplayMode(), gKnownPixelFormats[pixelFormatIndex], bmdVideoOutputFlagDefault, &displayModeSupport, NULL) == S_OK)
 109                             && (displayModeSupport != bmdDisplayModeNotSupported))
 110                         {
 111                             printf("%s\t", gKnownPixelFormatNames[pixelFormatIndex]);
 112                         }
 113                         pixelFormatIndex++;
 114                     }*/
 115                     free(displayModeString);
 116                 }
 117
 118                 // Release the IDeckLinkDisplayMode object to prevent a leak
 119                 displayMode->Release();
 120             }
 121             devicelist->addItem(deviceName, availableModes);
 122             found = true;
 123         }
 124
 125
 126         //print_attributes(deckLink);
 127
 128         // ** List the video output display modes supported by the card
 129         //print_output_modes(deckLink);
 130
 131         // ** List the input and output capabilities of the card
 132         //print_capabilities(deckLink);
 133
 134         // Release the IDeckLink instance when we've finished with it to prevent leaks
 135         deckLink->Release();
 136     }
 137
 138     deckLinkIterator->Release();
 139     if(modelist != NULL && devicelist->count() > 0) {
 140         QStringList modes = devicelist->itemData(devicelist->currentIndex()).toStringList();
 141         modelist->insertItems(0, modes);
 142     }
 143     return found;
 144 }