mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-11-24 02:31:03 +00:00
168 lines
6.3 KiB
Python
168 lines
6.3 KiB
Python
# -*- Mode: Python -*-
|
|
# vi:si:et:sw=4:sts=4:ts=4
|
|
#
|
|
# gst-python - Python bindings for GStreamer
|
|
# Copyright (C) 2002 David I. Lehn
|
|
# Copyright (C) 2004 Johan Dahlin
|
|
# Copyright (C) 2005 Edward Hervey
|
|
#
|
|
# This library is free software; you can redistribute it and/or
|
|
# modify it under the terms of the GNU Lesser General Public
|
|
# License as published by the Free Software Foundation; either
|
|
# version 2.1 of the License, or (at your option) any later version.
|
|
#
|
|
# This library 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
|
|
# Lesser General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU Lesser General Public
|
|
# License along with this library; if not, write to the Free Software
|
|
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
import sys
|
|
from common import gst, unittest
|
|
|
|
class CapsTest(unittest.TestCase):
|
|
def setUp(self):
|
|
self.caps = gst.caps_from_string('video/x-raw-yuv,width=10,framerate=5.0;video/x-raw-rgb,width=15,framerate=10.0')
|
|
self.structure = self.caps[0]
|
|
self.any = gst.Caps("ANY")
|
|
self.empty = gst.Caps()
|
|
|
|
def testCapsMime(self):
|
|
mime = self.structure.get_name()
|
|
assert mime == 'video/x-raw-yuv'
|
|
|
|
def testCapsList(self):
|
|
'check if we can access Caps as a list'
|
|
structure = self.caps[0]
|
|
mime = structure.get_name()
|
|
assert mime == 'video/x-raw-yuv'
|
|
structure = self.caps[1]
|
|
mime = structure.get_name()
|
|
assert mime == 'video/x-raw-rgb'
|
|
|
|
def testCapsConstructEmpty(self):
|
|
caps = gst.Caps()
|
|
assert isinstance(caps, gst.Caps)
|
|
|
|
def testCapsConstructFromString(self):
|
|
caps = gst.Caps('video/x-raw-yuv,width=10')
|
|
assert isinstance(caps, gst.Caps)
|
|
assert len(caps) == 1
|
|
assert isinstance(caps[0], gst.Structure)
|
|
assert caps[0].get_name() == 'video/x-raw-yuv'
|
|
assert isinstance(caps[0]['width'], int)
|
|
assert caps[0]['width'] == 10
|
|
|
|
def testCapsConstructFromStructure(self):
|
|
struct = gst.structure_from_string('video/x-raw-yuv,width=10')
|
|
caps = gst.Caps(struct)
|
|
assert isinstance(caps, gst.Caps)
|
|
assert len(caps) == 1
|
|
assert isinstance(caps[0], gst.Structure)
|
|
assert caps[0].get_name() == 'video/x-raw-yuv'
|
|
assert isinstance(caps[0]['width'], int)
|
|
assert caps[0]['width'] == 10
|
|
|
|
def testCapsConstructFromStructures(self):
|
|
struct1 = gst.structure_from_string('video/x-raw-yuv,width=10')
|
|
struct2 = gst.structure_from_string('video/x-raw-rgb,height=20.0')
|
|
caps = gst.Caps(struct1, struct2)
|
|
assert isinstance(caps, gst.Caps)
|
|
assert len(caps) == 2
|
|
struct = caps[0]
|
|
assert isinstance(struct, gst.Structure), struct
|
|
assert struct.get_name() == 'video/x-raw-yuv', struct.get_name()
|
|
assert struct.has_key('width')
|
|
assert isinstance(struct['width'], int)
|
|
assert struct['width'] == 10
|
|
struct = caps[1]
|
|
assert isinstance(struct, gst.Structure), struct
|
|
assert struct.get_name() == 'video/x-raw-rgb', struct.get_name()
|
|
assert struct.has_key('height')
|
|
assert isinstance(struct['height'], float)
|
|
assert struct['height'] == 20.0
|
|
|
|
def testCapsRefernceStructs(self):
|
|
'test that shows why it\'s not a good idea to use structures by reference'
|
|
caps = gst.Caps('hi/mom,width=0')
|
|
structure = caps[0]
|
|
del caps
|
|
assert structure['width'] == 0
|
|
|
|
|
|
def testCapsStructureChange(self):
|
|
'test if changing the structure of the caps works by reference'
|
|
assert self.structure['width'] == 10
|
|
self.structure['width'] = 5
|
|
assert self.structure['width'] == 5.0
|
|
# check if we changed the caps as well
|
|
structure = self.caps[0]
|
|
assert structure['width'] == 5.0
|
|
|
|
def testCapsBadConstructor(self):
|
|
struct = gst.structure_from_string('video/x-raw-yuv,width=10')
|
|
self.assertRaises(TypeError, gst.Caps, None)
|
|
self.assertRaises(TypeError, gst.Caps, 1)
|
|
self.assertRaises(TypeError, gst.Caps, 2.0)
|
|
self.assertRaises(TypeError, gst.Caps, object)
|
|
self.assertRaises(TypeError, gst.Caps, 1, 2, 3)
|
|
|
|
# This causes segfault!
|
|
#self.assertRaises(TypeError, gst.Caps, struct, 10, None)
|
|
|
|
def testTrueFalse(self):
|
|
'test that comparisons using caps work the intended way'
|
|
assert self.any # not empty even though it has no structures
|
|
assert not self.empty
|
|
assert not gst.Caps('EMPTY') # also empty
|
|
assert gst.Caps('your/mom')
|
|
|
|
def testComparisons(self):
|
|
assert self.empty < self.any
|
|
assert self.empty < self.structure
|
|
assert self.empty < self.caps
|
|
assert self.caps < self.any
|
|
assert self.empty <= self.empty
|
|
assert self.caps <= self.caps
|
|
assert self.caps <= self.any
|
|
assert self.empty == "EMPTY"
|
|
assert self.caps != self.any
|
|
assert self.empty != self.any
|
|
assert self.any > self.empty
|
|
assert self.any >= self.empty
|
|
|
|
def testFilters(self):
|
|
name = 'video/x-raw-yuv'
|
|
filtercaps = gst.Caps(*[struct for struct in self.caps if struct.get_name() == name])
|
|
intersection = self.caps & 'video/x-raw-yuv'
|
|
assert filtercaps == intersection
|
|
|
|
def doSubtract(self, set, subset):
|
|
'''mimic the test in GStreamer core's testsuite/caps/subtract.c'''
|
|
assert not set - set
|
|
assert not subset - subset
|
|
assert not subset - set
|
|
test = set - subset
|
|
assert test
|
|
test2 = test | subset
|
|
test = test2 - set
|
|
assert not test
|
|
#our own extensions foolow here
|
|
assert subset == set & subset
|
|
assert set == set | subset
|
|
assert set - subset == set ^ subset
|
|
|
|
def testSubtract(self):
|
|
self.doSubtract(
|
|
gst.Caps ("some/mime, _int = [ 1, 2 ], list = { \"A\", \"B\", \"C\" }"),
|
|
gst.Caps ("some/mime, _int = 1, list = \"A\""))
|
|
self.doSubtract(
|
|
gst.Caps ("some/mime, _double = (double) 1.0; other/mime, _int = { 1, 2 }"),
|
|
gst.Caps ("some/mime, _double = (double) 1.0"))
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|