def __init__(self, **unused_kw): Loggable.__init__(self) self.videowidth = 720 self.videoheight = 576 self.videorate = gst.Fraction(25, 1) self.videopar = gst.Fraction(1, 1) self.audiochannels = 2 self.audiorate = 44100 self.audiodepth = 16 self.vencoder = "theoraenc" self.aencoder = "vorbisenc" self.muxer = "oggmux" self.containersettings = {} self.acodecsettings = {} self.vcodecsettings = {} self.muxers = available_muxers() self.vencoders = available_video_encoders() self.aencoders = available_audio_encoders() self.muxers = available_combinations(self.muxers, self.vencoders, self.aencoders)
def updateSettings(self): """ Updates and returns the ExportSettings configured in the widget """ # Video Settings width = self.videowidthspin.get_value() height = self.videoheightspin.get_value() rate = gst.Fraction( *self.video_rates[self.videoratecbox.get_active()][1:]) self.settings.setVideoProperties(width, height, rate) # Audio Settings nbchanns = self.audiochanncbox.get_active() + 1 rate = self.audio_rates[self.audioratecbox.get_active()][1] depth = self.audio_depths[self.audiodepthcbox.get_active()][1] self.settings.setAudioProperties(nbchanns, rate, depth) # Encoders muxer = self.settings.muxers[ self.muxercombobox.get_active()].get_name() vidx = self.vcodeccbox.get_active() if vidx < len(self.validvencoders): vencoder = self.validvencoders[vidx].get_name() elif vidx == len(self.validvencoders): vencoder = None else: self.warning("we don't want any video stream") aidx = self.acodeccbox.get_active() if aidx < len(self.validaencoders): aencoder = self.validaencoders[aidx].get_name() elif aidx == len(self.validaencoders): aencoder = None else: self.warning("we don't want any audio stream") self.settings.setEncoders(muxer, vencoder, aencoder) # encoder/muxer settings # only store cached values if no different factory was chosen. if muxer == self.muxer: self.settings.containersettings = self.containersettings else: self.settings.containersettings = {} if aencoder == self.aencoder: self.settings.acodecsettings = self.acodecsettings else: self.settings.acodecsettings = {} if vencoder == self.vencoder: self.settings.vcodecsettings = self.vcodecsettings else: self.settings.vcodecsettings = {} self.debug("Returning %s", self.settings) return self.settings
def get_pipeline_string(self, props): self.is_square = props.get('is-square', False) self.width = props.get('width', None) self.height = props.get('height', None) self.add_borders = props.get('add-borders', True) self.deintMode = props.get('deinterlace-mode', 'auto') self.deintMethod = props.get('deinterlace-method', 'ffmpeg') self.kuinterval = props.get('keyunits-interval', 0) * gst.MSECOND self.volume_level = props.get('volume', 1) fr = props.get('framerate', None) self.framerate = fr and gst.Fraction(fr[0], fr[1]) or None self._parse_aditional_properties(props) return self.get_pipeline_template(props)
def _onValueChangedCb(self, widget, dynamic, prop): value = dynamic.getWidgetValue() #FIXME Workaround in order to make aspectratiocrop working if isinstance(value, gst.Fraction): value = gst.Fraction(int(value.num), int(value.denom)) if value != self._current_element_values.get(prop.name): self.action_log.begin("Effect property change") self._current_effect_setting_ui.element.set_property( prop.name, value) self.action_log.commit() self._current_element_values[prop.name] = value
def _parseText(self, text): match = self.fraction_regex.match(text) groups = match.groups() num = 1.0 denom = 1.0 if groups[0]: num = float(groups[0]) if groups[2]: if groups[2] == "M": num = num * 1000 denom = 1001 elif groups[2][1:]: denom = float(groups[2][1:]) return gst.Fraction(num, denom)
def __init__(self): gst.Bin.__init__(self) self.videoscale = gst.element_factory_make("videoscale", "smart-videoscale") # set the scaling method to bilinear (cleaner) # FIXME : we should figure out if better methods are available in the # future, or ask the user which method he wants to use # FIXME : Instead of having the set_caps() method, # use proper caps negotiation self.videoscale.props.method = 1 self.videobox = gst.element_factory_make("videobox", "smart-videobox") self.capsfilter = gst.element_factory_make("capsfilter", "smart-capsfilter") self.add(self.videoscale, self.capsfilter, self.videobox) gst.element_link_many(self.videoscale, self.capsfilter, self.videobox) self._sinkPad = gst.GhostPad("sink", self.videoscale.get_pad("sink")) self._sinkPad.set_active(True) self._srcPad = gst.GhostPad("src", self.videobox.get_pad("src")) self._srcPad.set_active(True) self.add_pad(self._sinkPad) self.add_pad(self._srcPad) self._sinkPad.set_setcaps_function(self._sinkSetCaps) # input/output values self.capsin = None self.widthin = -1 self.heightin = -1 self.parin = gst.Fraction(1, 1) self.darin = gst.Fraction(1, 1) self.capsout = None self.widthout = -1 self.heightout = -1 self.parout = gst.Fraction(1, 1) self.darout = gst.Fraction(1, 1)
def create_pipeline(self): p = gst.Pipeline() width, height = self.framesize.split("x") width, height = int(width), int(height) if self.location: src = gst.element_factory_make("filesrc") src.props.location = self.location if self.format == "I420": bpp = 1.5 elif self.format == "UYVY": bpp = 2 src.props.blocksize = int(width * height * bpp) else: src = gst.element_factory_make("videotestsrc") src.props.num_buffers = self.num_buffers self.bitrates = self.bitrateseq.split(',') bitrate = self.bitrate enc = gst.element_factory_make(self.element, "encoder") enc.props.bitrate = bitrate enc.props.max_bitrate = self.max_bitrate if self.mode is not None: enc.props.mode = self.mode if self.intra_refresh is not None: enc.props.intra_refresh = self.intra_refresh s = gst.Structure("video/x-raw-yuv") s["format"] = gst.Fourcc(self.format) s["width"] = width s["height"] = height s["framerate"] = gst.Fraction(self.framerate, 1) capf_raw = gst.element_factory_make("capsfilter") capf_raw.props.caps = gst.Caps(s) ident = gst.element_factory_make("identity") videorate = gst.element_factory_make("videorate") sink = gst.element_factory_make("fakesink") p.add(src, capf_raw, videorate, enc, ident, sink) gst.element_link_many(src, capf_raw, videorate, enc, ident, sink) ident.connect("handoff", self.handoff) ident.set_property("signal-handoffs", True) return p
def _reset(self): self.debug("resetting ourselves") self._outputrate = None self._srccaps = None # number of outputted buffers self._offset = 0 self._segment = gst.Segment() self._segment.init(gst.FORMAT_TIME) self._needsegment = True self._bufferduration = 0 self._outputrate = gst.Fraction(25, 1) # this is the buffer we store and repeatedly output self._buffer = None # this will be set by our task self.last_return = gst.FLOW_OK
def get_pipeline_string(self, properties): capsString = properties.get('format', 'video/x-raw-yuv') if capsString == 'video/x-raw-yuv': capsString = '%s,format=(fourcc)I420' % capsString # Filtered caps struct = gst.structure_from_string(capsString) for k in 'width', 'height': if k in properties: struct[k] = properties[k] if 'framerate' in properties: framerate = properties['framerate'] struct['framerate'] = gst.Fraction(framerate[0], framerate[1]) # always set par struct['pixel-aspect-ratio'] = gst.Fraction(1, 1) if 'pixel-aspect-ratio' in properties: par = properties['pixel-aspect-ratio'] struct['pixel-aspect-ratio'] = gst.Fraction(par[0], par[1]) # If RGB, set something ffmpegcolorspace can convert. if capsString == 'video/x-raw-rgb': struct['red_mask'] = 0xff00 caps = gst.Caps(struct) is_live = 'is-live=true' overlay = "" overlayTimestamps = properties.get('overlay-timestamps', False) if overlayTimestamps: overlay = " timeoverlay ! " return "videotestsrc %s name=source ! " % is_live + overlay + \ "identity name=identity silent=TRUE ! %s" % caps
def __init__(self, framerate=gst.Fraction(25, 1)): gst.Bin.__init__(self) self._framerate = framerate self._videorate = gst.element_factory_make("videorate") self._capsfilter = gst.element_factory_make("capsfilter") self.add(self._videorate, self._capsfilter) self._videorate.link(self._capsfilter) # Create source and sink pads self._sinkPad = gst.GhostPad('sink', self._videorate.get_pad('sink')) self._srcPad = gst.GhostPad('src', self._capsfilter.get_pad('src')) self.add_pad(self._sinkPad) self.add_pad(self._srcPad) self._setFramerate(framerate)
def testDurationCheckImage(self): self.discoverer.current_duration = gst.CLOCK_TIME_NONE pngdec = gst.element_factory_make('pngdec') self.discoverer.pipeline.add(pngdec) pad = pngdec.get_pad('src') caps = gst.Caps(pad.get_caps()[0]) caps[0]['width'] = 320 caps[0]['height'] = 240 caps[0]['framerate'] = gst.Fraction(0, 1) pad.set_caps(caps) self.discoverer._newDecodedPadCb(None, pad, False) self.discoverer.addUri('illbepopped') self.discoverer._finishAnalysis("foo") self.failUnlessEqual(self.error, None) self.failUnlessEqual(self.discoverer.current_duration, gst.CLOCK_TIME_NONE)
def __init__(self, instance, ui_manager): gtk.Table.__init__(self, rows=2, columns=1, homogeneous=False) Loggable.__init__(self) Zoomable.__init__(self) self.log("Creating Timeline") self._updateZoom = True self.project = None self.ui_manager = ui_manager self.app = instance self._temp_objects = None self._factories = None self._finish_drag = False self._position = 0 self._state = gst.STATE_NULL self._createUI() self._prev_duration = 0 self.rate = gst.Fraction(1, 1)
def _sink_setcaps(self, unused_pad, caps): self.debug("caps %s" % caps.to_string()) downcaps = self.srcpad.peer_get_caps().copy() self.debug("downcaps %s" % downcaps.to_string()) # methodology # 1. We override any incoming framerate ccaps = gst.Caps(caps) for struct in ccaps: if struct.has_key("framerate"): try: del struct["framerate"] except: self.warning("Couldn't remove 'framerate' from %s" % struct.to_string()) # 2. we do the intersection of our incoming stripped caps # and the downstream caps intersect = ccaps.intersect(downcaps) if intersect.is_empty(): self.warning("no negotiation possible !") return False # 3. for each candidate in the intersection, we try to set that # candidate downstream for candidate in intersect: self.debug("Trying %s" % candidate.to_string()) if self.srcpad.peer_accept_caps(candidate): self.debug("accepted ! %s" % candidate.to_string()) # 4. When we have an accepted caps downstream, we store the negotiated # framerate and return if not candidate.has_key("framerate") or \ not isinstance(candidate["framerate"], gst.Fraction): candidate["framerate"] = gst.Fraction(25, 1) self._outputrate = candidate["framerate"] self._bufferduration = gst.SECOND * self._outputrate.denom / self._outputrate.num self._srccaps = candidate.copy() res = self.srcpad.set_caps(self._srccaps) return res # 5. If we can't find an accepted candidate, we return False return False
def create_pipeline(self): p = gst.Pipeline() width, height = self.framesize.split("x") width, height = int(width), int(height) src = gst.element_factory_make("videotestsrc") src.props.num_buffers = self.num_buffers bitrate = self.bitrate scaler = gst.element_factory_make("videoscale") enc = gst.element_factory_make(self.element, "encoder") if self.mode is not None: enc.props.mode = self.mode if self.intra_refresh is not None: enc.props.intra_refresh = self.intra_refresh enc.props.bitrate = bitrate ident = gst.element_factory_make("identity") sink = gst.element_factory_make("fakesink") s = gst.Structure("video/x-raw-yuv") s["format"] = gst.Fourcc(self.format) s["width"] = width s["height"] = height s["framerate"] = gst.Fraction(self.framerate, 1) caps = gst.element_factory_make("capsfilter", "capsf") caps.props.caps = gst.Caps(s) p.add(src, scaler, caps, enc, ident, sink) gst.element_link_many(src, scaler, caps, enc, ident, sink) ident.connect("handoff", self.handoff) ident.set_property("signal-handoffs", True) return p
def testParAndDar(self): caps = gst.Caps('video/x-raw-int, width=320, height=240, ' 'pixel-aspect-ratio=2/1') stream = VideoStream(caps) self.failUnlessEqual(stream.par, gst.Fraction(2, 1)) self.failUnlessEqual(stream.dar, gst.Fraction(640, 240)) caps = gst.Caps('video/x-raw-int, width=320, height=240') stream = VideoStream(caps) self.failUnlessEqual(stream.par, gst.Fraction(1, 1)) self.failUnlessEqual(stream.dar, gst.Fraction(320, 240)) # no width and height, default to 4/3 caps = gst.Caps('video/x-raw-int') stream = VideoStream(caps) self.failUnlessEqual(stream.par, gst.Fraction(1, 1)) self.failUnlessEqual(stream.dar, gst.Fraction(4, 3))
def get_pipeline_string(self, properties): # setup the properties self.bus = None self.videowidth = properties.get('width', 240) self.videoheight = properties.get( 'height', int(576 * self.videowidth/720.)) self.videoframerate = properties.get('framerate', (25, 2)) self.filelocation = properties.get('location') vstruct = gst.structure_from_string( "video/x-raw-yuv,width=%(width)d,height=%(height)d" % dict(width=self.videowidth, height=self.videoheight)) vstruct['framerate'] = gst.Fraction(self.videoframerate[0], self.videoframerate[1]) vcaps = gst.Caps(vstruct) self.run_discoverer() template = ( 'filesrc location=%(location)s' ' ! oggdemux name=demux' ' demux. ! queue ! theoradec name=theoradec' ' ! identity name=videolive single-segment=true silent=true' ' ! videorate name=videorate' ' ! videoscale' ' ! %(vcaps)s' ' ! identity name=vident sync=true silent=true' ' ! @feeder:video@' ' demux. ! queue ! vorbisdec name=vorbisdec' ' ! identity name=audiolive single-segment=true silent=true' ' ! audioconvert' ' ! audio/x-raw-int,width=16,depth=16,signed=(boolean)true' ' ! identity name=aident sync=true silent=true' ' ! @feeder:audio@' % dict(location=self.filelocation, vcaps=vcaps)) return template
def create_pipeline(self): p = gst.Pipeline() width, height = self.framesize.split("x") width, height = int(width), int(height) if self.location: src = gst.element_factory_make("filesrc") src.props.location = self.location if self.format == "I420": bpp = 1.5 elif self.format == "UYVY": bpp = 2 src.props.blocksize = int(width * height * bpp) else: src = gst.element_factory_make("videotestsrc") src.props.num_buffers = self.num_buffers enc = gst.element_factory_make(self.element) enc.props.bitrate = self.bitrate sink = gst.element_factory_make("filesink") sink.props.location = self.tmp_filename s = gst.Structure("video/x-raw-yuv") s["format"] = gst.Fourcc(self.format) s["width"] = width s["height"] = height s["framerate"] = gst.Fraction(self.framerate, 1) capf = gst.element_factory_make("capsfilter") capf.props.caps = gst.Caps(s) p.add(src, capf, enc, sink) if not gst.element_link_many(src, capf, enc, sink): print " pipeline creation error !!" return p
def get_pipeline_string(self, props): if props.get('scaled-width', None) is not None: self.warnDeprecatedProperties(['scaled-width']) self.is_square = props.get('is-square', False) self.width = props.get('width', 0) self.height = props.get('height', 0) decoder = props.get('decoder', 'dvdec') if not self.is_square and not self.height: self.height = int(576 * self.width/720.) # assuming PAL self.add_borders = props.get('add-borders', True) guid = "guid=%s" % props.get('guid', 0) self.deintMode = props.get('deinterlace-mode', 'auto') self.deintMethod = props.get('deinterlace-method', 'ffmpeg') fr = props.get('framerate', None) if fr is not None: self.framerate = gst.Fraction(fr[0], fr[1]) else: self.framerate = None # FIXME: might be nice to factor out dv1394src ! dvdec so we can # replace it with videotestsrc of the same size and PAR, so we can # unittest the pipeline # need a queue in case tcpserversink blocks somehow template = ('dv1394src %s' ' ! tee name=t' ' ! queue leaky=2 max-size-time=1000000000' ' ! dvdemux name=demux' ' demux. ! queue ! %s name=decoder' ' ! @feeder:video@' ' demux. ! queue ! audio/x-raw-int ' ' ! volume name=setvolume' ' ! level name=volumelevel message=true ' ' ! @feeder:audio@' ' t. ! queue ! @feeder:dv@' % (guid, decoder)) return template
def __init__(self, framerate=gst.Fraction(25, 1)): gst.Bin.__init__(self) self._framerate = framerate self._videorate = gst.element_factory_make("videorate") self._capsfilter = gst.element_factory_make("capsfilter") self.add(self._videorate, self._capsfilter) self._videorate.link(self._capsfilter) # Set properties if gstreamer.element_has_property(self._videorate, 'skip-to-first'): self._videorate.set_property('skip-to-first', True) # Create source and sink pads self._sinkPad = gst.GhostPad('sink', self._videorate.get_pad('sink')) self._srcPad = gst.GhostPad('src', self._capsfilter.get_pad('src')) self.add_pad(self._sinkPad) self.add_pad(self._srcPad) self._sinkPad.set_event_function(self.eventfunc) self._setFramerate(framerate)
def _add_video_effects(self): # Add the effects to the component but don't plug them until we have a # valid video pad props = self.config['properties'] is_square = props.get('is-square', False) add_borders = props.get('add-borders', False) width = props.get('width', None) height = props.get('height', None) fr = props.get('framerate', (25, 2)) framerate = gst.Fraction(fr[0], fr[1]) self.vr = videorate.Videorate('videorate', None, self.pipeline, framerate) self.addEffect(self.vr) #self.vr.effectBin.set_state(gst.STATE_PLAYING) self.debug("Videorate added") self.videoscaler = videoscale.Videoscale('videoscale', self, None, self.pipeline, width, height, is_square, add_borders) self.addEffect(self.videoscaler) #self.videoscaler.effectBin.set_state(gst.STATE_PLAYING) self.debug("Videoscaler added")
if self.samples <= self.window.windowSize: return True # Ignore these, our sliding window isn't very smart self.data[0].append(processing_time * float(self.framerate) * 100.0) self.data[1].append(self.window.average * float(self.framerate) * 100.0) self.data[2].append(self.window.max * float(self.framerate) * 100.0) print "This frame: %.2f: %.2f%%. Average: %.2f%%. Peak: %.2f%%" % ( processing_time, processing_time * float(self.framerate) * 100.0, self.window.average * float(self.framerate) * 100.0, self.window.max * float(self.framerate) * 100.0) return True if len(sys.argv) == 2: framerates = [(30, 1), (25, 1), (25, 2), (None, None)] sizes = [(800, 600), (400, 300), (None, None)] # Other useful sizes here for framerate in framerates: for size in sizes: if framerate[1]: fr = gst.Fraction(framerate[0], framerate[1]) else: fr = None infile = sys.argv[1] outfileTemplate = sys.argv[1] + ".%dx%d@%.2f.png" bench = TheoraBench(sys.argv[1], outfileTemplate, size[0], size[1], fr) bench.run() else: print "Usage: %s filename.ogg" % sys.argv[0]
def __init__(self, filename, max_interleave=1.0, timeout=3000): """ filename: str; absolute path of the file to be discovered. max_interleave: int or float; the maximum frame interleave in seconds. The value must be greater than the input file frame interleave or the discoverer may not find out all input file's streams. The default value is 1 second and you shouldn't have to change it, changing it mean larger discovering time and bigger memory usage. timeout: int; duration in ms for the discovery to complete. """ gobject.GObject.__init__(self) self.mimetype = None self.audiocaps = {} self.videocaps = {} self.videowidth = 0 self.videoheight = 0 self.videorate = gst.Fraction(0, 1) self.audiofloat = False self.audiorate = 0 self.audiodepth = 0 self.audiowidth = 0 self.audiochannels = 0 self.audiolength = 0L self.videolength = 0L self.audiobitrate = None self.videobitrate = None self.segmentlength = None self.is_video = False self.is_audio = False self.otherstreams = [] self.finished = False self.tags = {} self._success = False self._nomorepads = False self._max_interleave = max_interleave if not os.path.isfile(filename): self.debug("File '%s' does not exist, finished" % filename) self.finished = True return # the initial elements of the pipeline self.src = gst.element_factory_make("filesrc") self.src.set_property("location", filename) self.src.set_property("blocksize", 1000000) self.dbin = gst.element_factory_make("decodebin2") self.add(self.src, self.dbin) self.src.link(self.dbin) self.typefind = self.dbin.get_by_name("typefind") # callbacks self.typefind.connect("have-type", self._have_type_cb) self.dbin.connect("new-decoded-pad", self._new_decoded_pad_cb) self.dbin.connect("no-more-pads", self._no_more_pads_cb) self.dbin.connect("unknown-type", self._unknown_type_cb)
def ts2frame(self, ts): """Converts timestamp to a frame number""" return long(round(gst.Fraction(ts, gst.SECOND) * self.fr))
def getDAR(self): return gst.Fraction(self.videowidth, self.videoheight) * self.videopar
def valueChanged(unused_widget, widget, target): target.set_text(str(widget.getWidgetValue())) widgets = ( (PathWidget, "file:///home/", ()), (TextWidget, "banana", ()), (TextWidget, "words only", ("^([a-zA-Z]+\s*)+$", )), (TextWidget, "numbers only", ("^\d+$", ("12", "14"))), (NumericWidget, 42, (100, 1)), (ToggleWidget, True, ()), (ChoiceWidget, "banana", ((("banana", "banana"), ("apple", "apple"), ("pear", "pear")), )), (ColorWidget, 0x336699FF, (int, )), (FontWidget, "Sans 9", ()), (FractionWidget, "30M", (gst.FractionRange(gst.Fraction(1, 1), gst.Fraction(30000, 1001)), )), (FractionWidget, gst.Fraction(25000, 1001), ( gst.FractionRange(gst.Fraction(1, 1), gst.Fraction(30000, 1001)), ( "25:1", gst.Fraction(30, 1), "30M", ), )), ) W = gtk.Window() v = gtk.VBox() t = gtk.Table()
def gst_buffer_from_ndarray(ndarray): ''' Wrap a gst buffer object around the given ndarray object. The input must be a 2-D record array. dtype should define the fields: "red", "green", "blue" and optionally "alpha". The type of the fields must be uint8. ''' width = ndarray.shape[1] height = ndarray.shape[0] print 'WIDTHHEIGHT', width, height dtype = ndarray.dtype ## must at least have 'red','green','blue' fields to be RGB image required_fields = ('red', 'green', 'blue') hasrgb = reduce(operator.and_, map(dtype.fields.__contains__, required_fields)) if not hasrgb: raise ValueError('array must have at least fields: %s' % (required_fields, )) ## fields must all be uint8 (dtype.char == 'B') hasbytes = reduce(operator.and_, [desc[0].char == 'B' for desc in dtype.fields.values()]) if not hasbytes: raise ValueError('all fields in array records must be uint8') mimetype = 'video/x-raw-rgb' buffer_endianness = 'big' mask_type = '>i4' nfields = len(dtype.fields) channels = filter(dtype.fields.__contains__, ('red', 'green', 'blue', 'alpha')) ## only going to deal with 8 bit channels bytespp = len(channels) bpp = 8 * bytespp rgb_depth = 24 if buffer_endianness == 'big': offset = 4 - bytespp else: offset = 0 # create channel masks for Caps masks = {} for channel in channels: mask = numpy.zeros(4, dtype=numpy.uint8) pos = dtype.fields[channel][1] mask[pos + offset] = 255 mask = mask.view(mask_type) mask = int(mask[0]) masks[channel + '_mask'] = mask ## make caps based on type of array if buffer_endianness == 'big': endianness = 4321 elif buffer_endianness == 'little': endianness = 1234 #caps = gst.caps_new_simple(mimetype, width=width, height=height, framerate=gst.Fraction(0), bpp=bpp, depth=rgb_depth, endianness=endianness, **masks) caps = gst.Caps(mimetype) cap = caps[0] cap['width'] = 182 cap['height'] = 126 cap['framerate'] = gst.Fraction(0) cap['bpp'] = bpp cap['depth'] = rgb_depth cap['endianness'] = endianness for key, value in masks.items(): cap[key] = value print 'NEW BUFFER CAPS' print_caps(caps) print '' # make buffer and attach array data and new caps buf = gst.Buffer(ndarray.data) buf.set_caps(caps) return buf
def getWidgetValue(self): if self.last_valid: return self._parseText(self.last_valid) return gst.Fraction(1, 1)
from pitivi.ui.common import\ model,\ frame_rates,\ audio_rates,\ audio_depths,\ audio_channels,\ get_combo_value,\ set_combo_value from pitivi.ui.preset import AudioPresetManager, DuplicatePresetNameException,\ VideoPresetManager # FIXME: are we sure the following tables correct? pixel_aspect_ratios = model((str, object), ( (_("Square"), gst.Fraction(1, 1)), (_("480p"), gst.Fraction(10, 11)), (_("480i"), gst.Fraction(8, 9)), (_("480p Wide"), gst.Fraction(40, 33)), (_("480i Wide"), gst.Fraction(32, 27)), (_("576p"), gst.Fraction(12, 11)), (_("576i"), gst.Fraction(16, 15)), (_("576p Wide"), gst.Fraction(16, 11)), (_("576i Wide"), gst.Fraction(64, 45)), )) display_aspect_ratios = model((str, object), ( (_("Standard (4:3)"), gst.Fraction(4, 3)), (_("DV (15:11)"), gst.Fraction(15, 11)), (_("DV Widescreen (16:9)"), gst.Fraction(16, 9)), (_("Cinema (1.37)"), gst.Fraction(11, 8)),
def setWidgetValue(self, value): width, height = value dar = gst.Fraction(width, height) self.dwidthWidget.setWidgetValue(width) self.dheightWidget.setWidgetValue(height)
def getSAR(self): width = int(self.width_spinbutton.get_value()) height = int(self.height_spinbutton.get_value()) return gst.Fraction(width, height)