|
def | __init__ (self, *args, **kwargs) |
|
def | getInstance () |
|
def | load (self) |
|
def | getAvailableSplitModes (self, INOUT) |
|
def | getAvailableDeinterlaceModes (self, INOUT) |
|
def | hasContrast (self) |
|
def | getContrast (self) |
|
def | setContrast (self, contrast) |
|
def | hasSaturation (self) |
|
def | getSaturation (self) |
|
def | setSaturation (self, saturation) |
|
def | hasHue (self) |
|
def | getHue (self) |
|
def | setHue (self, hue) |
|
def | hasBrightness (self) |
|
def | getBrightness (self) |
|
def | setBrightness (self, brightness) |
|
def | hasColorTemp (self) |
|
def | getColorTemp (self) |
|
def | setColorTemp (self, colortemp) |
|
def | hasScalerSharpness (self) |
|
def | getScalerSharpness (self) |
|
def | setScalerSharpness (self, sharpness) |
|
def | hasSplitMode (self) |
|
def | getSplitMode (self) |
|
def | setSplitMode (self, mode) |
|
def | hasSharpness (self) |
|
def | getSharpness (self) |
|
def | setSharpness (self, sharpness) |
|
def | hasAutoFlesh (self) |
|
def | getAutoFlesh (self) |
|
def | setAutoFlesh (self, level) |
|
def | hasGreenBoost (self) |
|
def | getGreenBoost (self) |
|
def | setGreenBoost (self, level) |
|
def | hasBlueBoost (self) |
|
def | getBlueBoost (self) |
|
def | setBlueBoost (self, level) |
|
def | hasDynamicContrast (self) |
|
def | getDynamicContrast (self) |
|
def | setDynamicContrast (self, contrast) |
|
def | hasBlockNoiseReduction (self) |
|
def | getBlockNoiseReduction (self) |
|
def | setBlockNoiseReduction (self, level) |
|
def | hasMosquitoNoiseReduction (self) |
|
def | getMosquitoNoiseReduction (self) |
|
def | setMosquitoNoiseReduction (self, level) |
|
def | hasDigitalContourRemoval (self) |
|
def | getDigitalContourRemoval (self) |
|
def | setDigitalContourRemoval (self, level) |
|
def | hasApplyChanges (self) |
|
def | applyChanges (self) |
|
def | hasDeinterlaceMode (self) |
|
def | getDeinterlaceMode (self) |
|
def | setDeinterlaceMode (self, mode) |
|
def | getContrastRange (self) |
|
def | getSaturationRange (self) |
|
def | getHueRange (self) |
|
def | getBrightnessRange (self) |
|
def | getColorTempRange (self) |
|
def | getScalerSharpnessRange (self) |
|
def | getSplitModeDefault (self) |
|
def | getSharpnessRange (self) |
|
def | getAutoFleshRange (self) |
|
def | getGreenBoostRange (self) |
|
def | getBlueBoostRange (self) |
|
def | getDynamicContrastRange (self) |
|
def | getBlockNoiseReductionRange (self) |
|
def | getMosquitoNoiseReductionRange (self) |
|
def | getDigitalContourRemovalRange (self) |
|
|
| thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') |
|
| getInstance = staticmethod(getInstance) |
|
| SM_OFF = _enigma.eVideoManager_SM_OFF |
|
| SM_LEFT = _enigma.eVideoManager_SM_LEFT |
|
| SM_RIGHT = _enigma.eVideoManager_SM_RIGHT |
|
| DM_OFF = _enigma.eVideoManager_DM_OFF |
|
| DM_ON = _enigma.eVideoManager_DM_ON |
|
| DM_AUTO = _enigma.eVideoManager_DM_AUTO |
|
| DM_BOB = _enigma.eVideoManager_DM_BOB |
|
◆ __init__()
def enigma.eVideoManager.__init__ |
( |
|
self, |
|
|
* |
args, |
|
|
** |
kwargs |
|
) |
| |
◆ applyChanges()
def enigma.eVideoManager.applyChanges |
( |
|
self | ) |
|
applyChanges(eVideoManager self)
◆ getAutoFlesh()
def enigma.eVideoManager.getAutoFlesh |
( |
|
self | ) |
|
getAutoFlesh(eVideoManager self) -> int
◆ getAutoFleshRange()
def enigma.eVideoManager.getAutoFleshRange |
( |
|
self | ) |
|
getAutoFleshRange(eVideoManager self) -> ePropertyRange
◆ getAvailableDeinterlaceModes()
def enigma.eVideoManager.getAvailableDeinterlaceModes |
( |
|
self, |
|
|
|
INOUT |
|
) |
| |
getAvailableDeinterlaceModes(eVideoManager self, IntList INOUT)
◆ getAvailableSplitModes()
def enigma.eVideoManager.getAvailableSplitModes |
( |
|
self, |
|
|
|
INOUT |
|
) |
| |
getAvailableSplitModes(eVideoManager self, IntList INOUT)
◆ getBlockNoiseReduction()
def enigma.eVideoManager.getBlockNoiseReduction |
( |
|
self | ) |
|
getBlockNoiseReduction(eVideoManager self) -> int
◆ getBlockNoiseReductionRange()
def enigma.eVideoManager.getBlockNoiseReductionRange |
( |
|
self | ) |
|
getBlockNoiseReductionRange(eVideoManager self) -> ePropertyRange
◆ getBlueBoost()
def enigma.eVideoManager.getBlueBoost |
( |
|
self | ) |
|
getBlueBoost(eVideoManager self) -> int
◆ getBlueBoostRange()
def enigma.eVideoManager.getBlueBoostRange |
( |
|
self | ) |
|
getBlueBoostRange(eVideoManager self) -> ePropertyRange
◆ getBrightness()
def enigma.eVideoManager.getBrightness |
( |
|
self | ) |
|
getBrightness(eVideoManager self) -> int
◆ getBrightnessRange()
def enigma.eVideoManager.getBrightnessRange |
( |
|
self | ) |
|
getBrightnessRange(eVideoManager self) -> ePropertyRange
◆ getColorTemp()
def enigma.eVideoManager.getColorTemp |
( |
|
self | ) |
|
getColorTemp(eVideoManager self) -> int
◆ getColorTempRange()
def enigma.eVideoManager.getColorTempRange |
( |
|
self | ) |
|
getColorTempRange(eVideoManager self) -> ePropertyRange
◆ getContrast()
def enigma.eVideoManager.getContrast |
( |
|
self | ) |
|
getContrast(eVideoManager self) -> int
◆ getContrastRange()
def enigma.eVideoManager.getContrastRange |
( |
|
self | ) |
|
getContrastRange(eVideoManager self) -> ePropertyRange
◆ getDeinterlaceMode()
def enigma.eVideoManager.getDeinterlaceMode |
( |
|
self | ) |
|
getDeinterlaceMode(eVideoManager self) -> int
◆ getDigitalContourRemoval()
def enigma.eVideoManager.getDigitalContourRemoval |
( |
|
self | ) |
|
getDigitalContourRemoval(eVideoManager self) -> int
◆ getDigitalContourRemovalRange()
def enigma.eVideoManager.getDigitalContourRemovalRange |
( |
|
self | ) |
|
getDigitalContourRemovalRange(eVideoManager self) -> ePropertyRange
◆ getDynamicContrast()
def enigma.eVideoManager.getDynamicContrast |
( |
|
self | ) |
|
getDynamicContrast(eVideoManager self) -> int
◆ getDynamicContrastRange()
def enigma.eVideoManager.getDynamicContrastRange |
( |
|
self | ) |
|
getDynamicContrastRange(eVideoManager self) -> ePropertyRange
◆ getGreenBoost()
def enigma.eVideoManager.getGreenBoost |
( |
|
self | ) |
|
getGreenBoost(eVideoManager self) -> int
◆ getGreenBoostRange()
def enigma.eVideoManager.getGreenBoostRange |
( |
|
self | ) |
|
getGreenBoostRange(eVideoManager self) -> ePropertyRange
◆ getHue()
def enigma.eVideoManager.getHue |
( |
|
self | ) |
|
getHue(eVideoManager self) -> int
◆ getHueRange()
def enigma.eVideoManager.getHueRange |
( |
|
self | ) |
|
getHueRange(eVideoManager self) -> ePropertyRange
◆ getInstance()
def enigma.eVideoManager.getInstance |
( |
| ) |
|
getInstance() -> eVideoManager
◆ getMosquitoNoiseReduction()
def enigma.eVideoManager.getMosquitoNoiseReduction |
( |
|
self | ) |
|
getMosquitoNoiseReduction(eVideoManager self) -> int
◆ getMosquitoNoiseReductionRange()
def enigma.eVideoManager.getMosquitoNoiseReductionRange |
( |
|
self | ) |
|
getMosquitoNoiseReductionRange(eVideoManager self) -> ePropertyRange
◆ getSaturation()
def enigma.eVideoManager.getSaturation |
( |
|
self | ) |
|
getSaturation(eVideoManager self) -> int
◆ getSaturationRange()
def enigma.eVideoManager.getSaturationRange |
( |
|
self | ) |
|
getSaturationRange(eVideoManager self) -> ePropertyRange
◆ getScalerSharpness()
def enigma.eVideoManager.getScalerSharpness |
( |
|
self | ) |
|
getScalerSharpness(eVideoManager self) -> int
◆ getScalerSharpnessRange()
def enigma.eVideoManager.getScalerSharpnessRange |
( |
|
self | ) |
|
getScalerSharpnessRange(eVideoManager self) -> ePropertyRange
◆ getSharpness()
def enigma.eVideoManager.getSharpness |
( |
|
self | ) |
|
getSharpness(eVideoManager self) -> int
◆ getSharpnessRange()
def enigma.eVideoManager.getSharpnessRange |
( |
|
self | ) |
|
getSharpnessRange(eVideoManager self) -> ePropertyRange
◆ getSplitMode()
def enigma.eVideoManager.getSplitMode |
( |
|
self | ) |
|
getSplitMode(eVideoManager self) -> int
◆ getSplitModeDefault()
def enigma.eVideoManager.getSplitModeDefault |
( |
|
self | ) |
|
getSplitModeDefault(eVideoManager self) -> int
◆ hasApplyChanges()
def enigma.eVideoManager.hasApplyChanges |
( |
|
self | ) |
|
hasApplyChanges(eVideoManager self) -> bool
◆ hasAutoFlesh()
def enigma.eVideoManager.hasAutoFlesh |
( |
|
self | ) |
|
hasAutoFlesh(eVideoManager self) -> bool
◆ hasBlockNoiseReduction()
def enigma.eVideoManager.hasBlockNoiseReduction |
( |
|
self | ) |
|
hasBlockNoiseReduction(eVideoManager self) -> bool
◆ hasBlueBoost()
def enigma.eVideoManager.hasBlueBoost |
( |
|
self | ) |
|
hasBlueBoost(eVideoManager self) -> bool
◆ hasBrightness()
def enigma.eVideoManager.hasBrightness |
( |
|
self | ) |
|
hasBrightness(eVideoManager self) -> bool
◆ hasColorTemp()
def enigma.eVideoManager.hasColorTemp |
( |
|
self | ) |
|
hasColorTemp(eVideoManager self) -> bool
◆ hasContrast()
def enigma.eVideoManager.hasContrast |
( |
|
self | ) |
|
hasContrast(eVideoManager self) -> bool
◆ hasDeinterlaceMode()
def enigma.eVideoManager.hasDeinterlaceMode |
( |
|
self | ) |
|
hasDeinterlaceMode(eVideoManager self) -> bool
◆ hasDigitalContourRemoval()
def enigma.eVideoManager.hasDigitalContourRemoval |
( |
|
self | ) |
|
hasDigitalContourRemoval(eVideoManager self) -> bool
◆ hasDynamicContrast()
def enigma.eVideoManager.hasDynamicContrast |
( |
|
self | ) |
|
hasDynamicContrast(eVideoManager self) -> bool
◆ hasGreenBoost()
def enigma.eVideoManager.hasGreenBoost |
( |
|
self | ) |
|
hasGreenBoost(eVideoManager self) -> bool
◆ hasHue()
def enigma.eVideoManager.hasHue |
( |
|
self | ) |
|
hasHue(eVideoManager self) -> bool
◆ hasMosquitoNoiseReduction()
def enigma.eVideoManager.hasMosquitoNoiseReduction |
( |
|
self | ) |
|
hasMosquitoNoiseReduction(eVideoManager self) -> bool
◆ hasSaturation()
def enigma.eVideoManager.hasSaturation |
( |
|
self | ) |
|
hasSaturation(eVideoManager self) -> bool
◆ hasScalerSharpness()
def enigma.eVideoManager.hasScalerSharpness |
( |
|
self | ) |
|
hasScalerSharpness(eVideoManager self) -> bool
◆ hasSharpness()
def enigma.eVideoManager.hasSharpness |
( |
|
self | ) |
|
hasSharpness(eVideoManager self) -> bool
◆ hasSplitMode()
def enigma.eVideoManager.hasSplitMode |
( |
|
self | ) |
|
hasSplitMode(eVideoManager self) -> bool
◆ load()
def enigma.eVideoManager.load |
( |
|
self | ) |
|
◆ setAutoFlesh()
def enigma.eVideoManager.setAutoFlesh |
( |
|
self, |
|
|
|
level |
|
) |
| |
setAutoFlesh(eVideoManager self, int level)
◆ setBlockNoiseReduction()
def enigma.eVideoManager.setBlockNoiseReduction |
( |
|
self, |
|
|
|
level |
|
) |
| |
setBlockNoiseReduction(eVideoManager self, int level)
◆ setBlueBoost()
def enigma.eVideoManager.setBlueBoost |
( |
|
self, |
|
|
|
level |
|
) |
| |
setBlueBoost(eVideoManager self, int level)
◆ setBrightness()
def enigma.eVideoManager.setBrightness |
( |
|
self, |
|
|
|
brightness |
|
) |
| |
setBrightness(eVideoManager self, int brightness)
◆ setColorTemp()
def enigma.eVideoManager.setColorTemp |
( |
|
self, |
|
|
|
colortemp |
|
) |
| |
setColorTemp(eVideoManager self, int const colortemp)
◆ setContrast()
def enigma.eVideoManager.setContrast |
( |
|
self, |
|
|
|
contrast |
|
) |
| |
setContrast(eVideoManager self, int contrast)
◆ setDeinterlaceMode()
def enigma.eVideoManager.setDeinterlaceMode |
( |
|
self, |
|
|
|
mode |
|
) |
| |
setDeinterlaceMode(eVideoManager self, int mode)
◆ setDigitalContourRemoval()
def enigma.eVideoManager.setDigitalContourRemoval |
( |
|
self, |
|
|
|
level |
|
) |
| |
setDigitalContourRemoval(eVideoManager self, int level)
◆ setDynamicContrast()
def enigma.eVideoManager.setDynamicContrast |
( |
|
self, |
|
|
|
contrast |
|
) |
| |
setDynamicContrast(eVideoManager self, int contrast)
◆ setGreenBoost()
def enigma.eVideoManager.setGreenBoost |
( |
|
self, |
|
|
|
level |
|
) |
| |
setGreenBoost(eVideoManager self, int level)
◆ setHue()
def enigma.eVideoManager.setHue |
( |
|
self, |
|
|
|
hue |
|
) |
| |
setHue(eVideoManager self, int hue)
◆ setMosquitoNoiseReduction()
def enigma.eVideoManager.setMosquitoNoiseReduction |
( |
|
self, |
|
|
|
level |
|
) |
| |
setMosquitoNoiseReduction(eVideoManager self, int level)
◆ setSaturation()
def enigma.eVideoManager.setSaturation |
( |
|
self, |
|
|
|
saturation |
|
) |
| |
setSaturation(eVideoManager self, int saturation)
◆ setScalerSharpness()
def enigma.eVideoManager.setScalerSharpness |
( |
|
self, |
|
|
|
sharpness |
|
) |
| |
setScalerSharpness(eVideoManager self, int sharpness)
◆ setSharpness()
def enigma.eVideoManager.setSharpness |
( |
|
self, |
|
|
|
sharpness |
|
) |
| |
setSharpness(eVideoManager self, int sharpness)
◆ setSplitMode()
def enigma.eVideoManager.setSplitMode |
( |
|
self, |
|
|
|
mode |
|
) |
| |
setSplitMode(eVideoManager self, int mode)
◆ DM_AUTO
enigma.eVideoManager.DM_AUTO = _enigma.eVideoManager_DM_AUTO |
|
static |
◆ DM_BOB
enigma.eVideoManager.DM_BOB = _enigma.eVideoManager_DM_BOB |
|
static |
◆ DM_OFF
enigma.eVideoManager.DM_OFF = _enigma.eVideoManager_DM_OFF |
|
static |
◆ DM_ON
enigma.eVideoManager.DM_ON = _enigma.eVideoManager_DM_ON |
|
static |
◆ getInstance
enigma.eVideoManager.getInstance = staticmethod(getInstance) |
|
static |
◆ SM_LEFT
enigma.eVideoManager.SM_LEFT = _enigma.eVideoManager_SM_LEFT |
|
static |
◆ SM_OFF
enigma.eVideoManager.SM_OFF = _enigma.eVideoManager_SM_OFF |
|
static |
◆ SM_RIGHT
enigma.eVideoManager.SM_RIGHT = _enigma.eVideoManager_SM_RIGHT |
|
static |
◆ thisown
enigma.eVideoManager.thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') |
|
static |
The documentation for this class was generated from the following file: