bartvdbraak/blender
1
0
Fork 4
Code Issues 4 Pull Requests 1 Actions 1 Packages Projects Releases Wiki Activity
046904e3fc
blender/source/gameengine/VideoTexture/DeckLink.cpp
Campbell Barton 9f5621bb4a Cleanup: comment blocks
2016-07-02 10:08:33 +10:00

814 lines
24 KiB
C++
Raw Blame History

/*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* The Original Code is Copyright (C) 2015, Blender Foundation
* All rights reserved.
*
* The Original Code is: all of this file.
*
* Contributor(s): Blender Foundation.
*
* ***** END GPL LICENSE BLOCK *****
*/
/** \file gameengine/VideoTexture/Texture.cpp
* \ingroup bgevideotex
*/
#ifdef WITH_GAMEENGINE_DECKLINK
// implementation
// FFmpeg defines its own version of stdint.h on Windows.
// Decklink needs FFmpeg, so it uses its version of stdint.h
// this is necessary for INT64_C macro
#ifndef __STDC_CONSTANT_MACROS
#define __STDC_CONSTANT_MACROS
#endif
// this is necessary for UINTPTR_MAX (used by atomic-ops)
#ifndef __STDC_LIMIT_MACROS
#define __STDC_LIMIT_MACROS
#endif
#include "atomic_ops.h"
#include "EXP_PyObjectPlus.h"
#include "KX_KetsjiEngine.h"
#include "KX_PythonInit.h"
#include "DeckLink.h"
#include <memory.h>
// macro for exception handling and logging
#define CATCH_EXCP catch (Exception & exp) \
{ exp.report(); return NULL; }
static struct
{
const char *name;
BMDDisplayMode mode;
} sModeStringTab[] = {
{ "NTSC", bmdModeNTSC },
{ "NTSC2398", bmdModeNTSC2398 },
{ "PAL", bmdModePAL },
{ "NTSCp", bmdModeNTSCp },
{ "PALp", bmdModePALp },
/* HD 1080 Modes */
{ "HD1080p2398", bmdModeHD1080p2398 },
{ "HD1080p24", bmdModeHD1080p24 },
{ "HD1080p25", bmdModeHD1080p25 },
{ "HD1080p2997", bmdModeHD1080p2997 },
{ "HD1080p30", bmdModeHD1080p30 },
{ "HD1080i50", bmdModeHD1080i50 },
{ "HD1080i5994", bmdModeHD1080i5994 },
{ "HD1080i6000", bmdModeHD1080i6000 },
{ "HD1080p50", bmdModeHD1080p50 },
{ "HD1080p5994", bmdModeHD1080p5994 },
{ "HD1080p6000", bmdModeHD1080p6000 },
/* HD 720 Modes */
{ "HD720p50", bmdModeHD720p50 },
{ "HD720p5994", bmdModeHD720p5994 },
{ "HD720p60", bmdModeHD720p60 },
/* 2k Modes */
{ "2k2398", bmdMode2k2398 },
{ "2k24", bmdMode2k24 },
{ "2k25", bmdMode2k25 },
/* DCI Modes (output only) */
{ "2kDCI2398", bmdMode2kDCI2398 },
{ "2kDCI24", bmdMode2kDCI24 },
{ "2kDCI25", bmdMode2kDCI25 },
/* 4k Modes */
{ "4K2160p2398", bmdMode4K2160p2398 },
{ "4K2160p24", bmdMode4K2160p24 },
{ "4K2160p25", bmdMode4K2160p25 },
{ "4K2160p2997", bmdMode4K2160p2997 },
{ "4K2160p30", bmdMode4K2160p30 },
{ "4K2160p50", bmdMode4K2160p50 },
{ "4K2160p5994", bmdMode4K2160p5994 },
{ "4K2160p60", bmdMode4K2160p60 },
// sentinel
{ NULL }
};
static struct
{
const char *name;
BMDPixelFormat format;
} sFormatStringTab[] = {
{ "8BitYUV", bmdFormat8BitYUV },
{ "10BitYUV", bmdFormat10BitYUV },
{ "8BitARGB", bmdFormat8BitARGB },
{ "8BitBGRA", bmdFormat8BitBGRA },
{ "10BitRGB", bmdFormat10BitRGB },
{ "12BitRGB", bmdFormat12BitRGB },
{ "12BitRGBLE", bmdFormat12BitRGBLE },
{ "10BitRGBXLE", bmdFormat10BitRGBXLE },
{ "10BitRGBX", bmdFormat10BitRGBX },
// sentinel
{ NULL }
};
ExceptionID DeckLinkBadDisplayMode, DeckLinkBadPixelFormat;
ExpDesc DeckLinkBadDisplayModeDesc(DeckLinkBadDisplayMode, "Invalid or unsupported display mode");
ExpDesc DeckLinkBadPixelFormatDesc(DeckLinkBadPixelFormat, "Invalid or unsupported pixel format");
HRESULT decklink_ReadDisplayMode(const char *format, size_t len, BMDDisplayMode *displayMode)
{
int i;
if (len == 0)
len = strlen(format);
for (i = 0; sModeStringTab[i].name != NULL; i++) {
if (strlen(sModeStringTab[i].name) == len &&
!strncmp(sModeStringTab[i].name, format, len))
{
*displayMode = sModeStringTab[i].mode;
return S_OK;
}
}
if (len != 4)
THRWEXCP(DeckLinkBadDisplayMode, S_OK);
// assume the user entered directly the mode value as a 4 char string
*displayMode = (BMDDisplayMode)((((uint32_t)format[0]) << 24) + (((uint32_t)format[1]) << 16) + (((uint32_t)format[2]) << 8) + ((uint32_t)format[3]));
return S_OK;
}
HRESULT decklink_ReadPixelFormat(const char *format, size_t len, BMDPixelFormat *pixelFormat)
{
int i;
if (!len)
len = strlen(format);
for (i = 0; sFormatStringTab[i].name != NULL; i++) {
if (strlen(sFormatStringTab[i].name) == len &&
!strncmp(sFormatStringTab[i].name, format, len))
{
*pixelFormat = sFormatStringTab[i].format;
return S_OK;
}
}
if (len != 4)
THRWEXCP(DeckLinkBadPixelFormat, S_OK);
// assume the user entered directly the mode value as a 4 char string
*pixelFormat = (BMDPixelFormat)((((uint32_t)format[0]) << 24) + (((uint32_t)format[1]) << 16) + (((uint32_t)format[2]) << 8) + ((uint32_t)format[3]));
return S_OK;
}
class DeckLink3DFrameWrapper : public IDeckLinkVideoFrame, IDeckLinkVideoFrame3DExtensions
{
public:
// IUnknown
virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID iid, LPVOID *ppv)
{
if (!memcmp(&iid, &IID_IDeckLinkVideoFrame3DExtensions, sizeof(iid))) {
if (mpRightEye) {
*ppv = (IDeckLinkVideoFrame3DExtensions*)this;
return S_OK;
}
}
return E_NOTIMPL;
}
virtual ULONG STDMETHODCALLTYPE AddRef(void) { return 1U; }
virtual ULONG STDMETHODCALLTYPE Release(void) { return 1U; }
// IDeckLinkVideoFrame
virtual long STDMETHODCALLTYPE GetWidth(void) { return mpLeftEye->GetWidth(); }
virtual long STDMETHODCALLTYPE GetHeight(void) { return mpLeftEye->GetHeight(); }
virtual long STDMETHODCALLTYPE GetRowBytes(void) { return mpLeftEye->GetRowBytes(); }
virtual BMDPixelFormat STDMETHODCALLTYPE GetPixelFormat(void) { return mpLeftEye->GetPixelFormat(); }
virtual BMDFrameFlags STDMETHODCALLTYPE GetFlags(void) { return mpLeftEye->GetFlags(); }
virtual HRESULT STDMETHODCALLTYPE GetBytes(void **buffer) { return mpLeftEye->GetBytes(buffer); }
virtual HRESULT STDMETHODCALLTYPE GetTimecode(BMDTimecodeFormat format,IDeckLinkTimecode **timecode)
{ return mpLeftEye->GetTimecode(format, timecode); }
virtual HRESULT STDMETHODCALLTYPE GetAncillaryData(IDeckLinkVideoFrameAncillary **ancillary)
{ return mpLeftEye->GetAncillaryData(ancillary); }
// IDeckLinkVideoFrame3DExtensions
virtual BMDVideo3DPackingFormat STDMETHODCALLTYPE Get3DPackingFormat(void)
{
return bmdVideo3DPackingLeftOnly;
}
virtual HRESULT STDMETHODCALLTYPE GetFrameForRightEye(
/* [out] */ IDeckLinkVideoFrame **rightEyeFrame)
{
mpRightEye->AddRef();
*rightEyeFrame = mpRightEye;
return S_OK;
}
// Constructor
DeckLink3DFrameWrapper(IDeckLinkVideoFrame *leftEye, IDeckLinkVideoFrame *rightEye)
{
mpLeftEye = leftEye;
mpRightEye = rightEye;
}
// no need for a destructor, it's just a wrapper
private:
IDeckLinkVideoFrame *mpLeftEye;
IDeckLinkVideoFrame *mpRightEye;
};
static void decklink_Reset(DeckLink *self)
{
self->m_lastClock = 0.0;
self->mDLOutput = NULL;
self->mUse3D = false;
self->mDisplayMode = bmdModeUnknown;
self->mKeyingSupported = false;
self->mHDKeyingSupported = false;
self->mSize[0] = 0;
self->mSize[1] = 0;
self->mFrameSize = 0;
self->mLeftFrame = NULL;
self->mRightFrame = NULL;
self->mKeyer = NULL;
self->mUseKeying = false;
self->mKeyingLevel = 255;
self->mUseExtend = false;
}
#ifdef __BIG_ENDIAN__
#define CONV_PIXEL(i) ((((i)>>16)&0xFF00)+(((i)&0xFF00)<<16)+((i)&0xFF00FF))
#else
#define CONV_PIXEL(i) ((((i)&0xFF)<<16)+(((i)>>16)&0xFF)+((i)&0xFF00FF00))
#endif
// adapt the pixel format and picture size from VideoTexture (RGBA) to DeckLink (BGRA)
static void decklink_ConvImage(uint32_t *dest, const short *destSize, const uint32_t *source, const short *srcSize, bool extend)
{
short w, h, x, y;
const uint32_t *s;
uint32_t *d, p;
bool sameSize = (destSize[0] == srcSize[0] && destSize[1] == srcSize[1]);
if (sameSize || !extend) {
// here we convert pixel by pixel
w = (destSize[0] < srcSize[0]) ? destSize[0] : srcSize[0];
h = (destSize[1] < srcSize[1]) ? destSize[1] : srcSize[1];
for (y = 0; y < h; ++y) {
s = source + y*srcSize[0];
d = dest + y*destSize[0];
for (x = 0; x < w; ++x, ++s, ++d) {
*d = CONV_PIXEL(*s);
}
}
}
else {
// here we scale
// interpolation accumulator
int accHeight = srcSize[1] >> 1;
d = dest;
s = source;
// process image rows
for (y = 0; y < srcSize[1]; ++y) {
// increase height accum
accHeight += destSize[1];
// if pixel row has to be drawn
if (accHeight >= srcSize[1]) {
// decrease accum
accHeight -= srcSize[1];
// width accum
int accWidth = srcSize[0] >> 1;
// process row
for (x = 0; x < srcSize[0]; ++x, ++s) {
// increase width accum
accWidth += destSize[0];
// convert pixel
p = CONV_PIXEL(*s);
// if pixel has to be drown one or more times
while (accWidth >= srcSize[0]) {
// decrease accum
accWidth -= srcSize[0];
*d++ = p;
}
}
// if there should be more identical lines
while (accHeight >= srcSize[1]) {
accHeight -= srcSize[1];
// copy previous line
memcpy(d, d - destSize[0], 4 * destSize[0]);
d += destSize[0];
}
}
else {
// if we skip a source line
s += srcSize[0];
}
}
}
}
// DeckLink object allocation
static PyObject *DeckLink_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
// allocate object
DeckLink * self = reinterpret_cast<DeckLink*>(type->tp_alloc(type, 0));
// initialize object structure
decklink_Reset(self);
// m_leftEye is a python object, it's handled by python
self->m_leftEye = NULL;
self->m_rightEye = NULL;
// return allocated object
return reinterpret_cast<PyObject*>(self);
}
// forward declaration
PyObject *DeckLink_close(DeckLink *self);
int DeckLink_setSource(DeckLink *self, PyObject *value, void *closure);
// DeckLink object deallocation
static void DeckLink_dealloc(DeckLink *self)
{
// release renderer
Py_XDECREF(self->m_leftEye);
// close decklink
PyObject *ret = DeckLink_close(self);
Py_DECREF(ret);
// release object
Py_TYPE((PyObject *)self)->tp_free((PyObject *)self);
}
ExceptionID AutoDetectionNotAvail, DeckLinkOpenCard, DeckLinkBadFormat, DeckLinkInternalError;
ExpDesc AutoDetectionNotAvailDesc(AutoDetectionNotAvail, "Auto detection not yet available");
ExpDesc DeckLinkOpenCardDesc(DeckLinkOpenCard, "Cannot open card for output");
ExpDesc DeckLinkBadFormatDesc(DeckLinkBadFormat, "Invalid or unsupported output format, use <mode>[/3D]");
ExpDesc DeckLinkInternalErrorDesc(DeckLinkInternalError, "DeckLink API internal error, please report");
// DeckLink object initialization
static int DeckLink_init(DeckLink *self, PyObject *args, PyObject *kwds)
{
IDeckLinkIterator* pIterator;
IDeckLinkAttributes* pAttributes;
IDeckLinkDisplayModeIterator* pDisplayModeIterator;
IDeckLinkDisplayMode* pDisplayMode;
IDeckLink* pDL;
char* p3D;
BOOL flag;
size_t len;
int i;
uint32_t displayFlags;
BMDVideoOutputFlags outputFlags;
BMDDisplayModeSupport support;
uint32_t* bytes;
// material ID
short cardIdx = 0;
// texture ID
char *format = NULL;
static const char *kwlist[] = {"cardIdx", "format", NULL};
// get parameters
if (!PyArg_ParseTupleAndKeywords(args, kwds, "|hs",
const_cast<char**>(kwlist), &cardIdx, &format))
return -1;
try {
if (format == NULL) {
THRWEXCP(AutoDetectionNotAvail, S_OK);
}
if ((p3D = strchr(format, '/')) != NULL && strcmp(p3D, "/3D"))
THRWEXCP(DeckLinkBadFormat, S_OK);
self->mUse3D = (p3D) ? true : false;
// read the mode
len = (p3D) ? (size_t)(p3D - format) : strlen(format);
// throws if bad mode
decklink_ReadDisplayMode(format, len, &self->mDisplayMode);
pIterator = BMD_CreateDeckLinkIterator();
pDL = NULL;
if (pIterator) {
i = 0;
while (pIterator->Next(&pDL) == S_OK) {
if (i == cardIdx) {
break;
}
i++;
pDL->Release();
pDL = NULL;
}
pIterator->Release();
}
if (!pDL) {
THRWEXCP(DeckLinkOpenCard, S_OK);
}
// detect the capabilities
if (pDL->QueryInterface(IID_IDeckLinkAttributes, (void**)&pAttributes) == S_OK) {
if (pAttributes->GetFlag(BMDDeckLinkSupportsInternalKeying, &flag) == S_OK && flag) {
self->mKeyingSupported = true;
if (pAttributes->GetFlag(BMDDeckLinkSupportsHDKeying, &flag) == S_OK && flag) {
self->mHDKeyingSupported = true;
}
}
pAttributes->Release();
}
if (pDL->QueryInterface(IID_IDeckLinkOutput, (void**)&self->mDLOutput) != S_OK) {
self->mDLOutput = NULL;
}
if (self->mKeyingSupported) {
pDL->QueryInterface(IID_IDeckLinkKeyer, (void **)&self->mKeyer);
}
// we don't need the device anymore, release to avoid leaking
pDL->Release();
if (!self->mDLOutput)
THRWEXCP(DeckLinkOpenCard, S_OK);
if (self->mDLOutput->GetDisplayModeIterator(&pDisplayModeIterator) != S_OK)
THRWEXCP(DeckLinkInternalError, S_OK);
displayFlags = (self->mUse3D) ? bmdDisplayModeSupports3D : 0;
outputFlags = (self->mUse3D) ? bmdVideoOutputDualStream3D : bmdVideoOutputFlagDefault;
pDisplayMode = NULL;
i = 0;
while (pDisplayModeIterator->Next(&pDisplayMode) == S_OK) {
if (pDisplayMode->GetDisplayMode() == self->mDisplayMode
&& (pDisplayMode->GetFlags() & displayFlags) == displayFlags) {
if (self->mDLOutput->DoesSupportVideoMode(self->mDisplayMode, bmdFormat8BitBGRA, outputFlags, &support, NULL) != S_OK ||
support == bmdDisplayModeNotSupported)
{
printf("Warning: DeckLink card %d reports no BGRA support, proceed anyway\n", cardIdx);
}
break;
}
pDisplayMode->Release();
pDisplayMode = NULL;
i++;
}
pDisplayModeIterator->Release();
if (!pDisplayMode)
THRWEXCP(DeckLinkBadFormat, S_OK);
self->mSize[0] = pDisplayMode->GetWidth();
self->mSize[1] = pDisplayMode->GetHeight();
self->mFrameSize = 4*self->mSize[0]*self->mSize[1];
pDisplayMode->Release();
if (self->mDLOutput->EnableVideoOutput(self->mDisplayMode, outputFlags) != S_OK)
// this shouldn't fail
THRWEXCP(DeckLinkOpenCard, S_OK);
if (self->mDLOutput->CreateVideoFrame(self->mSize[0], self->mSize[1], self->mSize[0] * 4, bmdFormat8BitBGRA, bmdFrameFlagFlipVertical, &self->mLeftFrame) != S_OK)
THRWEXCP(DeckLinkInternalError, S_OK);
// clear alpha channel in the frame buffer
self->mLeftFrame->GetBytes((void **)&bytes);
memset(bytes, 0, self->mFrameSize);
if (self->mUse3D) {
if (self->mDLOutput->CreateVideoFrame(self->mSize[0], self->mSize[1], self->mSize[0] * 4, bmdFormat8BitBGRA, bmdFrameFlagFlipVertical, &self->mRightFrame) != S_OK)
THRWEXCP(DeckLinkInternalError, S_OK);
// clear alpha channel in the frame buffer
self->mRightFrame->GetBytes((void **)&bytes);
memset(bytes, 0, self->mFrameSize);
}
}
catch (Exception & exp)
{
printf("DeckLink: exception when opening card %d: %s\n", cardIdx, exp.what());
exp.report();
// normally, the object should be deallocated
return -1;
}
// initialization succeeded
return 0;
}
// close added decklink
PyObject *DeckLink_close(DeckLink * self)
{
if (self->mLeftFrame)
self->mLeftFrame->Release();
if (self->mRightFrame)
self->mRightFrame->Release();
if (self->mKeyer)
self->mKeyer->Release();
if (self->mDLOutput)
self->mDLOutput->Release();
decklink_Reset(self);
Py_RETURN_NONE;
}
// refresh decklink key frame
static PyObject *DeckLink_refresh(DeckLink *self, PyObject *args)
{
// get parameter - refresh source
PyObject *param;
double ts = -1.0;
if (!PyArg_ParseTuple(args, "O|d:refresh", &param, &ts) || !PyBool_Check(param)) {
// report error
PyErr_SetString(PyExc_TypeError, "The value must be a bool");
return NULL;
}
// some trick here: we are in the business of loading a key frame in decklink,
// no use to do it if we are still in the same rendering frame.
// We find this out by looking at the engine current clock time
KX_KetsjiEngine* engine = KX_GetActiveEngine();
if (engine->GetClockTime() != self->m_lastClock)
{
self->m_lastClock = engine->GetClockTime();
// set source refresh
bool refreshSource = (param == Py_True);
uint32_t *leftEye = NULL;
uint32_t *rightEye = NULL;
// try to process key frame from source
try {
// check if optimization is possible
if (self->m_leftEye != NULL) {
ImageBase *leftImage = self->m_leftEye->m_image;
short * srcSize = leftImage->getSize();
self->mLeftFrame->GetBytes((void **)&leftEye);
if (srcSize[0] == self->mSize[0] && srcSize[1] == self->mSize[1])
{
// buffer has same size, can load directly
if (!leftImage->loadImage(leftEye, self->mFrameSize, GL_BGRA, ts))
leftEye = NULL;
}
else {
// scaling is required, go the hard way
unsigned int *src = leftImage->getImage(0, ts);
if (src != NULL)
decklink_ConvImage(leftEye, self->mSize, src, srcSize, self->mUseExtend);
else
leftEye = NULL;
}
}
if (leftEye) {
if (self->mUse3D && self->m_rightEye != NULL) {
ImageBase *rightImage = self->m_rightEye->m_image;
short * srcSize = rightImage->getSize();
self->mRightFrame->GetBytes((void **)&rightEye);
if (srcSize[0] == self->mSize[0] && srcSize[1] == self->mSize[1])
{
// buffer has same size, can load directly
rightImage->loadImage(rightEye, self->mFrameSize, GL_BGRA, ts);
}
else {
// scaling is required, go the hard way
unsigned int *src = rightImage->getImage(0, ts);
if (src != NULL)
decklink_ConvImage(rightEye, self->mSize, src, srcSize, self->mUseExtend);
}
}
if (self->mUse3D) {
DeckLink3DFrameWrapper frame3D(
(IDeckLinkVideoFrame*)self->mLeftFrame,
(IDeckLinkVideoFrame*)self->mRightFrame);
self->mDLOutput->DisplayVideoFrameSync(&frame3D);
}
else {
self->mDLOutput->DisplayVideoFrameSync((IDeckLinkVideoFrame*)self->mLeftFrame);
}
}
// refresh texture source, if required
if (refreshSource) {
if (self->m_leftEye)
self->m_leftEye->m_image->refresh();
if (self->m_rightEye)
self->m_rightEye->m_image->refresh();
}
}
CATCH_EXCP;
}
Py_RETURN_NONE;
}
// get source object
static PyObject *DeckLink_getSource(DeckLink *self, PyObject *value, void *closure)
{
// if source exists
if (self->m_leftEye != NULL) {
Py_INCREF(self->m_leftEye);
return reinterpret_cast<PyObject*>(self->m_leftEye);
}
// otherwise return None
Py_RETURN_NONE;
}
// set source object
int DeckLink_setSource(DeckLink *self, PyObject *value, void *closure)
{
// check new value
if (value == NULL || !pyImageTypes.in(Py_TYPE(value))) {
// report value error
PyErr_SetString(PyExc_TypeError, "Invalid type of value");
return -1;
}
// increase ref count for new value
Py_INCREF(value);
// release previous
Py_XDECREF(self->m_leftEye);
// set new value
self->m_leftEye = reinterpret_cast<PyImage*>(value);
// return success
return 0;
}
// get source object
static PyObject *DeckLink_getRight(DeckLink *self, PyObject *value, void *closure)
{
// if source exists
if (self->m_rightEye != NULL)
{
Py_INCREF(self->m_rightEye);
return reinterpret_cast<PyObject*>(self->m_rightEye);
}
// otherwise return None
Py_RETURN_NONE;
}
// set source object
static int DeckLink_setRight(DeckLink *self, PyObject *value, void *closure)
{
// check new value
if (value == NULL || !pyImageTypes.in(Py_TYPE(value)))
{
// report value error
PyErr_SetString(PyExc_TypeError, "Invalid type of value");
return -1;
}
// increase ref count for new value
Py_INCREF(value);
// release previous
Py_XDECREF(self->m_rightEye);
// set new value
self->m_rightEye = reinterpret_cast<PyImage*>(value);
// return success
return 0;
}
static PyObject *DeckLink_getKeying(DeckLink *self, PyObject *value, void *closure)
{
if (self->mUseKeying) Py_RETURN_TRUE;
else Py_RETURN_FALSE;
}
static int DeckLink_setKeying(DeckLink *self, PyObject *value, void *closure)
{
if (value == NULL || !PyBool_Check(value))
{
PyErr_SetString(PyExc_TypeError, "The value must be a bool");
return -1;
}
if (self->mKeyer != NULL)
{
if (value == Py_True)
{
if (self->mKeyer->Enable(false) != S_OK)
{
PyErr_SetString(PyExc_RuntimeError, "Error enabling keyer");
return -1;
}
self->mUseKeying = true;
self->mKeyer->SetLevel(self->mKeyingLevel);
}
else
{
self->mKeyer->Disable();
self->mUseKeying = false;
}
}
// success
return 0;
}
static PyObject *DeckLink_getLevel(DeckLink *self, PyObject *value, void *closure)
{
return Py_BuildValue("h", self->mKeyingLevel);
}
static int DeckLink_setLevel(DeckLink *self, PyObject *value, void *closure)
{
long level;
if (value == NULL || !PyLong_Check(value)) {
PyErr_SetString(PyExc_TypeError, "The value must be an integer from 0 to 255");
return -1;
}
level = PyLong_AsLong(value);
if (level > 255)
level = 255;
else if (level < 0)
level = 0;
self->mKeyingLevel = (uint8_t)level;
if (self->mUseKeying) {
if (self->mKeyer->SetLevel(self->mKeyingLevel) != S_OK) {
PyErr_SetString(PyExc_RuntimeError, "Error changin level of keyer");
return -1;
}
}
// success
return 0;
}
static PyObject *DeckLink_getExtend(DeckLink *self, PyObject *value, void *closure)
{
if (self->mUseExtend) Py_RETURN_TRUE;
else Py_RETURN_FALSE;
}
static int DeckLink_setExtend(DeckLink *self, PyObject *value, void *closure)
{
if (value == NULL || !PyBool_Check(value))
{
PyErr_SetString(PyExc_TypeError, "The value must be a bool");
return -1;
}
self->mUseExtend = (value == Py_True);
return 0;
}
// class DeckLink methods
static PyMethodDef decklinkMethods[] =
{
{ "close", (PyCFunction)DeckLink_close, METH_NOARGS, "Close dynamic decklink and restore original"},
{ "refresh", (PyCFunction)DeckLink_refresh, METH_VARARGS, "Refresh decklink from source"},
{NULL} /* Sentinel */
};
// class DeckLink attributes
static PyGetSetDef decklinkGetSets[] =
{
{ (char*)"source", (getter)DeckLink_getSource, (setter)DeckLink_setSource, (char*)"source of decklink (left eye)", NULL},
{ (char*)"right", (getter)DeckLink_getRight, (setter)DeckLink_setRight, (char*)"source of decklink (right eye)", NULL },
{ (char*)"keying", (getter)DeckLink_getKeying, (setter)DeckLink_setKeying, (char*)"whether keying is enabled (frame is alpha-composited with passthrough output)", NULL },
{ (char*)"level", (getter)DeckLink_getLevel, (setter)DeckLink_setLevel, (char*)"change the level of keying (overall alpha level of key frame, 0 to 255)", NULL },
{ (char*)"extend", (getter)DeckLink_getExtend, (setter)DeckLink_setExtend, (char*)"whether image should stretched to fit frame", NULL },
{ NULL }
};
// class DeckLink declaration
PyTypeObject DeckLinkType =
{
PyVarObject_HEAD_INIT(NULL, 0)
"VideoTexture.DeckLink", /*tp_name*/
sizeof(DeckLink), /*tp_basicsize*/
0, /*tp_itemsize*/
(destructor)DeckLink_dealloc,/*tp_dealloc*/
0, /*tp_print*/
0, /*tp_getattr*/
0, /*tp_setattr*/
0, /*tp_compare*/
0, /*tp_repr*/
0, /*tp_as_number*/
0, /*tp_as_sequence*/
0, /*tp_as_mapping*/
0, /*tp_hash */
0, /*tp_call*/
0, /*tp_str*/
0, /*tp_getattro*/
0, /*tp_setattro*/
&imageBufferProcs, /*tp_as_buffer*/
Py_TPFLAGS_DEFAULT, /*tp_flags*/
"DeckLink objects", /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
decklinkMethods, /* tp_methods */
0, /* tp_members */
decklinkGetSets, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
(initproc)DeckLink_init, /* tp_init */
0, /* tp_alloc */
DeckLink_new, /* tp_new */
};
#endif /* WITH_GAMEENGINE_DECKLINK */
Reference in New Issue View Git Blame Copy Permalink