@@ -1,4 +1,11 @@

 -------------------------------------------------------------------

+Sat Mar 14 15:34:58 UTC 2015 - aloisio@gmx.com

+

+- Update to 0.35

+  * full changelog at http://tovid.wikia.com/wiki/Tovid_changelog 

+- Fixed build for 13.2 and newer

+

+-------------------------------------------------------------------

 Fri Dec 26 15:40:08 UTC 2014 - obs@botter.cc

 - Require /usr/bin/mkisofs instead of just mkisofs [PM-118] 

​

@@ -10,13 +10,13 @@

 Summary:        Video conversion and DVD authoring tools

 Name:           tovid

-Version:        0.34

+Version:        0.35

 Release:        0.pm.1

 Group:          Productivity/Multimedia/Video/Editors and Convertors

-License:        GNU General Public License version 2 or later (GPLv2 or later)

+License:        GPL-2.0+

 Url:            http://tovid.sourceforge.net/

 # http://tovid.googlecode.com/files/tovid-%{version}.tar.gz

-Source:         tovid-%{version}.tar.bz2

+Source:         tovid-%{version}.tar.gz

 Source90:       %{name}-rpmlintrc

 BuildRoot:      %{_tmppath}/%{name}-%{version}-%{release}-root

 %if %suse_version > 1110

@@ -46,7 +46,11 @@

 %endif

 Requires:       python-cairo

 Requires:       python-imaging

-Requires:       python-wxGTK

+%if 0%{?suse_version} >= 1320

+Requires:       python-wxGTK >= 3.0

+%else

+Requires:       python-wxGTK < 3.0

+%endif

 Requires:       sox

 Requires:       transcode

 Requires:       vcdimager

@@ -66,7 +70,11 @@

 BuildRequires:  normalize

 BuildRequires:  python-cairo

 BuildRequires:  python-imaging

-BuildRequires:  python-wxGTK

+%if 0%{?suse_version} >= 1320

+BuildRequires:  python-wxGTK >= 3.0

+%else

+BuildRequires:  python-wxGTK < 3.0

+%endif

 BuildRequires:  sox

 BuildRequires:  transcode

 BuildRequires:  vcdimager

​

@@ -1,263 +0,0 @@

-"""This module is for authoring a DVD or (S)VCD using dvdauthor or vcdimager.

-"""

-

-__all__ = [

-    'Disc',

-    'Menu',

-    'Video',

-    'Group',

-    'Titleset',

-    'vcdimager_xml',

-    'dvdauthor_xml',

-]

-

-from libtovid import xml

-

-

-###

-### Supporting classes

-###

-

-class Video:

-    """A video title for inclusion on a video disc.

-    """

-    def __init__(self, filename, title=''):

-        self.filename = filename

-        self.title = title

-        self.chapters = []

-

-

-class Group:

-    """A group title for inclusion on a video disc.

-    """

-    def __init__(self, filenames, title):

-        self.filenames = filenames

-        self.title = title

-

-

-class Menu:

-    """A menu for navigating the titles on a video disc.

-    """

-    def __init__(self, filename='', videos=None):

-        """Create a menu linking to the given `Video`\s."""

-        self.filename = filename

-        self.videos = videos or []

-

-    def add(self, video):

-        """Add a `Video` to the Menu."""

-        self.videos.append(video)

-

-

-class Titleset:

-    """A group of `Video`\s, with an optional `Menu`.

-    """

-    def __init__(self, menu=None, videos=None):

-        """Create a Titleset containing the given `Video`\s.

-        """

-        self.menu = menu

-        self.videos = videos or []

-

-    def add(self, video):

-        """Add a `Video` to the Titleset."""

-        self.videos.append(video)

-

-

-class Disc:

-    """A video disc containing one or more `Titleset`\s, and an optional

-    top `Menu` for navigating to each Titleset.

-

-    """

-    def __init__(self, name='Untitled', format='dvd', tvsys='ntsc',

-                 titlesets=None):

-        """Create a Disc with the given properties.

-

-            format

-                'vcd', 'svcd', or 'dvd'

-            tvsys

-                'pal' or 'ntsc'

-            title

-                String containing the title of the disc

-            titlesets

-                List of `Titleset` objects

-        """

-        self.name = name

-        self.format = format

-        self.tvsys = tvsys

-        self.topmenu = None

-        self.titlesets = titlesets or []

-

-

-

-###

-### Internal functions

-###

-

-def _add_titleset(titleset, ts_id, segment_items, sequence_items, pbc):

-    """Add titleset content to a vcdimager XML structure. This function is

-    used internally, mainly to keep `vcdimager_xml` from being too long.

-    """

-    menu = titleset.menu

-    videos = titleset.videos

-    # Add menu

-    if menu:

-        segment_items.add('segment-item', src=menu.filename,

-                          id='seg-menu-%d' % ts_id)

-        # Add menu to pbc

-        selection = pbc.add('selection', id='select-menu-%d' % ts_id)

-        selection.add('bsn', '1')

-        # Link back to topmenu (not sure what'll happen if there isn't one...)

-        selection.add('return', ref='select-topmenu')

-        selection.add('loop', '0', jump_timing='immediate')

-        selection.add('play-item', ref='seg-menu-%d' % ts_id)

-        # Navigational links to titleset videos

-        for video_id in range(len(videos)):

-            selection.add('select',

-                          ref='play-title-%d-%d' % (ts_id, video_id))

-    # Add videos

-    for video_id, video in enumerate(videos):

-        # Add sequence items

-        sequence_item = sequence_items.add('sequence-item')

-        sequence_item.set(id='seq-title-%d-%d' % (ts_id, video_id),

-                          src=video.filename)

-        # Add chapter entries

-        for chapterid, chapter in enumerate(video.chapters):

-            sequence_item.add('entry', chapter, id='chapter-%d' % chapterid)

-        # Add playlists to pbc

-        playlist = pbc.add('playlist')

-        playlist.set(id='play-title-%d-%d' % (ts_id, video_id))

-        # Add prev/next links if appropriate

-        if 0 <= video_id < len(videos):

-            if 0 < video_id:

-                playlist.add('prev',

-                             ref='play-title-%d-%d' % (ts_id, video_id-1))

-            if video_id < len(videos) - 1:

-                playlist.add('next',

-                             ref='play-title-%d-%d' % (ts_id, video_id+1))

-        # Add a return link to the menu, if there is one

-        if menu:

-            playlist.add('return', ref='select-menu-%d' % ts_id)

-        playlist.add('wait', '0')

-        playlist.add('play-item', ref='seq-title-%d-%d' % (ts_id, video_id))

-

-

-###

-### Exported functions

-###

-

-def vcdimager_xml(disc):

-    """Return the vcdimager XML string for the given `Disc`.

-    """

-    assert isinstance(disc, Disc)

-    # XML header (will be added later)

-    header = '<?xml version="1.0"?>\n'

-    header += '<!DOCTYPE videocd PUBLIC "-//GNU/DTD VideoCD//EN"\n'

-    header += '  "http://www.gnu.org/software/vcdimager/videocd.dtd">\n'

-    # Root videocd element

-    attributes = {

-        'xmlns': 'http://www.gnu.org/software/vcdimager/1.0/',

-        'class': disc.format}

-    if disc.format == 'vcd':

-        attributes['version'] = '2.0'

-    else: # SVCD

-        attributes['version'] = '1.0'

-    root = xml.Element('videocd')

-    root.set(**attributes)

-    # Add info block

-    info = root.add('info')

-    info.add('album-id', 'VIDEO_DISC')

-    info.add('volume-count', '1')

-    info.add('volume-number', '1')

-    info.add('restriction', '0')

-    # Add pvd block

-    pvd = root.add('pvd')

-    pvd.add('volume-id', 'VIDEO_DISC')

-    pvd.add('system-id', 'CD-RTOS CD-BRIDGE')

-

-    # Add segment, sequence, and pbc

-    segment_items = root.add('segment-items')

-    sequence_items = root.add('sequence-items')

-    pbc = root.add('pbc')

-    # Add topmenu

-    if disc.topmenu:

-        segment_items.add('segment-item', src=disc.topmenu.filename,

-                          id='seg-topmenu')

-        selection = pbc.add('selection', id='select-topmenu')

-        selection.add('bsn', '1')

-        selection.add('loop', '0', jump_timing='immediate')

-        selection.add('play-item', ref='seg-topmenu')

-    # Add titlesets

-    for ts_id, titleset in enumerate(disc.titlesets):

-        _add_titleset(titleset, ts_id, segment_items, sequence_items, pbc)

-        # If we're doing a topmenu, add a link to the titleset menu

-        if disc.topmenu:

-            selection.add('select', ref='select-menu-%d' % ts_id)

-

-    # Return XML with header prepended

-    return header + str(root) + '\n'

-

-

-def dvdauthor_xml(disc):

-    """Return the dvdauthor XML string for the given `Disc`.

-    """

-    assert isinstance(disc, Disc)

-    # Root dvdauthor element

-    root = xml.Element('dvdauthor', dest=disc.name.replace(' ', '_'))

-    vmgm = root.add('vmgm')

-    # Add topmenu if present

-    if disc.topmenu:

-        menus = vmgm.add('menus')

-        menus.add('video')

-        pgc = menus.add('pgc', entry='title')

-        vob = pgc.add('vob', file=disc.topmenu.filename)

-        for index, titleset in enumerate(disc.titlesets):

-            if titleset.menu:

-                pgc.add('button', 'jump titleset %d menu;' % (index + 1))

-            else:

-                pgc.add('button', 'jump titleset %d;' % (index + 1))

-    # Add each titleset

-    for titleset in disc.titlesets:

-        menu = titleset.menu

-        ts = root.add('titleset')

-        # Add menu if present

-        if menu:

-            menus = ts.add('menus')

-            menus.add('video')

-            pgc = menus.add('pgc', entry='root')

-            vob = pgc.add('vob', file=menu.filename)

-            for index, video in enumerate(titleset.videos):

-                pgc.add('button', 'jump title %d;' % (index + 1))

-            if disc.topmenu:

-                pgc.add('button', 'jump vmgm menu;')

-        titles = ts.add('titles')

-        # Add a pgc for each video

-        for video in titleset.videos:

-            pgc = titles.add('pgc')

-            vob = pgc.add('vob', file=video.filename)

-            if video.chapters:

-                vob.set(chapters=','.join(video.chapters))

-            pgc.add('post', 'call menu;')

-    # Return XML string

-    return str(root) + '\n'

-

-

-if __name__ == '__main__':

-    menu1 = Menu('menu1.mpg')

-    videos1 = [

-        Video('video1.mpg'),

-        Video('video2.mpg'),

-        Video('video3.mpg')]

-    menu2 = Menu('menu2.mpg')

-    videos2 = [

-        Video('video4.mpg'),

-        Video('video5.mpg'),

-        Video('video6.mpg')]

-    titlesets = [

-        Titleset(menu1, videos1),

-        Titleset(menu2, videos2)]

-    disc = Disc('dvd_test', 'dvd', 'ntsc', titlesets)

-

-    print("dvdauthor XML example:")

-    print(dvdauthor_xml(disc))

-

-    print("vcdimager XML example:")

-    print(vcdimager_xml(disc))

​

-(directory)

​

@@ -1,7 +0,0 @@

-"""Backends, which do some task using a command-line program.

-

-This module is split into submodules, each named after the command-line

-program they predominantly rely on. Backends which use several of these

-submodules may be defined here in ``__init__.py``.

-"""

-

​

@@ -1,179 +0,0 @@

-"""Video encoding and identification using ``ffmpeg``.

-"""

-

-__all__ = [

-    'encode',

-    'encode_audio',

-    'identify',

-]

-

-import re

-from libtovid import log

-from libtovid import cli

-

-def encode(source, target, **kw):

-    """Encode a multimedia video using ffmpeg.

-

-        source

-            Input `~libtovid.media.MediaFile`

-        target

-            Output `~libtovid.media.MediaFile`

-        kw

-            Keyword arguments to customize encoding behavior

-

-    Supported keywords:

-

-        quant

-            Minimum quantization, from 1-31 (1 being fewest artifacts)

-        vbitrate

-            Maximum video bitrate, in kilobits per second.

-        abitrate

-            Audio bitrate, in kilobits per second

-        interlace

-            'top' or 'bottom', to do interlaced encoding with

-            top or bottom field first

-

-    For example::

-

-        ffmpeg_encode(source, target, quant=4, vbitrate=7000)

-    """

-    cmd = cli.Command('ffmpeg', '-y', '-i', source.filename)

-

-    # Use format/tvsys that ffmpeg knows about

-    if target.format in ['vcd', 'svcd', 'dvd']:

-        cmd.add('-tvstd', target.tvsys,

-                '-target', '%s-%s' % (target.tvsys, target.format))

-

-    # Interpret keyword arguments

-    if 'quant' in kw:

-        cmd.add('-qmin', kw['quant'], '-qmax', 31)

-    if 'vbitrate' in kw:

-        cmd.add('-b', '%dk' % kw['vbitrate'])

-    if 'abitrate' in kw:

-        cmd.add('-ab', '%dk' % kw['abitrate'])

-    if 'interlace' in kw:

-        if kw['interlace'] == 'bottom':

-            cmd.add('-top', 0, '-flags', '+alt+ildct+ilme')

-        elif kw['interlace'] == 'top':

-            cmd.add('-top', 1, '-flags', '+alt+ildct+ilme')

-

-    # Frame rate and audio sampling rate

-    cmd.add('-r', target.fps,

-            '-ar', target.samprate)

-

-    # Convert scale/expand to ffmpeg's padding system

-    if target.scale:

-        cmd.add('-s', '%sx%s' % target.scale)

-        # Letterbox if necessary

-        if target.expand != target.scale:

-            e_width, e_height = target.expand

-            s_width, s_height = target.scale

-            h_pad = (e_width - s_width) / 2

-            v_pad = (e_height - s_height) / 2

-            if h_pad > 0:

-                cmd.add('-padleft', h_pad, '-padright', h_pad)

-            if v_pad > 0:

-                cmd.add('-padtop', v_pad, '-padbottom', v_pad)

-

-    # Aspect

-    if target.widescreen:

-        cmd.add('-aspect', '16:9')

-    else:

-        cmd.add('-aspect', '4:3')

-

-    cmd.add(target.filename)

-    cmd.run()

-

-

-def encode_audio(source, audiofile, target):

-    """Encode the audio stream in a source file to a target format, saving

-    to the given filename.

-

-        source

-            Input `~libtovid.media.MediaFile`

-        audiofile

-            Filename for encoded audio

-        target

-            Output `~libtovid.media.MediaFile`

-

-    If no audio is present in the source file, encode silence.

-    """

-    cmd = cli.Command('ffmpeg')

-

-    # If source has audio, encode it

-    if source.has_audio:

-        cmd.add('-i', source.filename)

-    # Otherwise, encode silence (minimum 4 seconds)

-    else:

-        cmd.add('-f', 's16le', '-i', '/dev/zero')

-        if source.length < 4:

-            cmd.add('-t', '4.0')

-        else:

-            cmd.add('-t', '%f' % source.length)

-

-    cmd.add('-vn', '-ac', '2', '-ab', '224k')

-    cmd.add('-ar', target.samprate)

-    cmd.add('-acodec', target.acodec)

-    cmd.add('-y', audiofile)

-

-    cmd.run()

-

-

-from libtovid.media import MediaFile

-

-def identify(filename):

-    """Identify a video file using ffmpeg, and return a

-    `~libtovid.media.MediaFile` with the video's specifications.

-    """

-    result = MediaFile(filename)

-

-    cmd = cli.Command('ffmpeg', '-i', filename)

-    cmd.run(capture=True)

-

-    # ffmpeg puts its output on stderr

-    output = cmd.get_errors()

-

-    video_line = re.compile(''

-        'Stream (?P<tracknum>[^:]+): Video: ' # Track number (ex. #0.0)

-        '(?P<vcodec>[^,]+), '                 # Video codec (ex. mpeg4)

-        '(?P<colorspace>[^,]+), '             # Color space (ex. yuv420p)

-        '(?P<width>\d+)x(?P<height>\d+), '    # Resolution (ex. 720x480)

-        '((?P<vbitrate>\d+) kb/s, )?'         # Video bitrate (ex. 8000 kb/s)

-        '(?P<fps>[\d.]+)')                    # FPS (ex. 29.97 fps(r))

-

-    audio_line = re.compile(''

-        'Stream (?P<tracknum>[^:]+): Audio: ' # Track number (ex. #0.1)

-        '(?P<acodec>[^,]+), '                 # Audio codec (ex. mp3)

-        '(?P<samprate>\d+) Hz, '              # Sampling rate (ex. 44100 Hz)

-        '(?P<channels>[^,]+), '               # Channels (ex. stereo)

-        '(?P<abitrate>\d+) kb/s')             # Audio bitrate (ex. 128 kb/s)

-

-    # Parse ffmpeg output and set MediaFile attributes

-    for line in output.split('\n'):

-        video_match = video_line.search(line)

-        audio_match = audio_line.search(line)

-

-        if video_match:

-            m = video_match

-            result.vcodec = m.group('vcodec')

-            result.scale = (int(m.group('width')),

-                            int(m.group('height')))

-            result.expand = result.scale

-            result.fps = float(m.group('fps'))

-            if m.group('vbitrate'):

-                result.vbitrate = int(m.group('vbitrate'))

-

-        elif audio_match:

-            m = audio_match

-            result.acodec = m.group('acodec')

-            result.samprate = int(m.group('samprate'))

-            result.abitrate = int(m.group('abitrate'))

-            if m.group('channels') == '5.1':

-                result.channels = 6

-            elif m.group('channels') == 'stereo':

-                result.channels = 2

-            else:

-                result.channels = 1

-

-    return result

-

​

@@ -1,220 +0,0 @@

-"""Video and frame encoding using ``mpeg2enc``.

-"""

-

-__all__ = [

-    'encode',

-    'encode_video',

-    'encode_frames',

-]

-

-# TODO: Filter out some of the inter-backend dependencies

-

-import os, glob

-from libtovid import log

-from libtovid import util

-from libtovid import cli

-from libtovid.backend import mplex, mplayer, ffmpeg

-

-def encode(source, target, **kw):

-    """Encode a multimedia video using mplayer|yuvfps|mpeg2enc.

-

-        source

-            Input `~libtovid.media.MediaFile`

-        target

-            Output `~libtovid.media.MediaFile`

-        kw

-            Keyword arguments to customize encoding behavior

-

-    Supported keywords:

-

-        None yet

-

-    """

-    log.warning("This encoder is very experimental, and may not work.")

-

-    outname = target.filename

-    # YUV raw video FIFO, for piping video from mplayer to mpeg2enc

-    yuvfile = '%s.yuv' % outname

-    if os.path.exists(yuvfile):

-        os.remove(yuvfile)

-

-    # Filenames for intermediate streams (ac3/m2v etc.)

-    # Appropriate suffix for audio stream

-    if target.format in ['vcd', 'svcd']:

-        audiofile = '%s.mp2' % outname

-    else:

-        audiofile = '%s.ac3' % outname

-    # Appropriate suffix for video stream

-    if target.format == 'vcd':

-        videofile = '%s.m1v' % outname

-    else:

-        videofile = '%s.m2v' % outname

-    # Do audio

-    ffmpeg.encode_audio(source, audiofile, target)

-    # Do video

-    mplayer.rip_video(source, yuvfile, target)

-    encode_video(source, yuvfile, videofile, target)

-    # Combine audio and video

-    mplex.mux(videofile, audiofile, target)

-

-

-

-def encode_video(source, yuvfile, videofile, target):

-    """Encode a yuv4mpeg stream to an MPEG video stream.

-

-        source

-            Input `~libtovid.media.MediaFile`

-        yuvfile

-            Filename of .yuv stream coming from mplayer

-        videofile

-            Filename of .m[1|2]v to write encoded video stream to

-        target

-            Output `~libtovid.media.MediaFile`

-

-    """

-    # TODO: Control over quality (bitrate/quantization) and disc split size,

-    # corresp. to $VID_BITRATE, $MPEG2_QUALITY, $DISC_SIZE, etc.

-    # Missing options (compared to tovid)

-    # -S 700 -B 247 -b 2080 -v 0 -4 2 -2 1 -q 5 -H -o FILE

-    pipe = cli.Pipe()

-

-    # Feed the .yuv file into the pipeline

-    cat = cli.Command('cat', yuvfile)

-    pipe.add(cat)

-

-    # Adjust framerate if necessary by piping through yuvfps

-    if source.fps != target.fps:

-        log.info("Adjusting framerate")

-        yuvfps = cli.Command('yuvfps')

-        yuvfps.add('-r', util.float_to_ratio(target.fps))

-        pipe.add(yuvfps)

-

-    # Encode the resulting .yuv stream by piping into mpeg2enc

-    mpeg2enc = cli.Command('mpeg2enc')

-    # TV system

-    if target.tvsys == 'pal':

-        mpeg2enc.add('-F', '3', '-n', 'p')

-    elif target.tvsys == 'ntsc':

-        mpeg2enc.add('-F', '4', '-n', 'n')

-    # Format

-    format = target.format

-    if format == 'vcd':

-        mpeg2enc.add('-f', '1')

-    elif format == 'svcd':

-        mpeg2enc.add('-f', '4')

-    elif 'dvd' in format:

-        mpeg2enc.add('-f', '8')

-    # Aspect ratio

-    if target.widescreen:

-        mpeg2enc.add('-a', '3')

-    else:

-        mpeg2enc.add('-a', '2')

-    mpeg2enc.add('-o', videofile)

-    pipe.add(mpeg2enc)

-

-    # Run the pipeline to encode the video stream

-    pipe.run()

-

-

-# --------------------------------------------------------------------------

-#

-# Frame encoder

-#

-# --------------------------------------------------------------------------

-from libtovid import standard

-

-def encode_frames(imagedir, outfile, format, tvsys, aspect, interlaced=False):

-    """Convert an image sequence in the given directory to match a target

-    `~libtovid.media.MediaFile`, putting the output stream in outfile.

-

-        imagedir

-            Directory containing images (and only images)

-        outfile

-            Filename for output.

-        tvsys

-            TVsys desired for output (to deal with FPS)

-        aspect

-            Aspect ratio ('4:3', '16:9')

-        interlaced

-            Frames are interlaced material

-

-    Currently supports JPG and PNG images; input images must already be

-    at the desired target resolution.

-    """

-

-    # Use absolute path name

-    imagedir = os.path.abspath(imagedir)

-    print("Creating video stream from image sequence in %s" % imagedir)

-    # Determine image type

-    images = glob.glob("%s/*" % imagedir)

-    extension = images[0][-3:]

-    if extension not in ['jpg', 'png']:

-        raise ValueError("Image format '%s' isn't currently supported to "

-              "render video from still frames" % extension)

-    # Make sure remaining image files have the same extension

-    for img in images:

-        if not img.endswith(extension):

-            raise ValueError("%s does not have a .%s extension" %

-                  (img, extension))

-

-    pipe = cli.Pipe()

-

-    # Use jpeg2yuv/png2yuv to stream images

-    if extension == 'jpg':

-        jpeg2yuv = cli.Command('jpeg2yuv')

-

-        jpeg2yuv.add('-Ip') # Progressive

-

-        jpeg2yuv.add('-f', '%.3f' % standard.fps(tvsys),

-                     '-j', '%s/%%08d.%s' % (imagedir, extension))

-        pipe.add(jpeg2yuv)

-    elif extension == 'png':

-        #ls = cli.Command('sh', '-c', 'ls %s/*.png' % imagedir)

-        #xargs = cli.Command('xargs', '-n1', 'pngtopnm')

-        png2yuv = cli.Command('png2yuv')

-

-        png2yuv.add('-Ip') # Progressive

-

-

-        png2yuv.add('-f', '%.3f' % standard.fps(tvsys),

-                    '-j', '%s/%%08d.png' % (imagedir))

-

-        pipe.add(png2yuv)

-

-        #pipe.add(ls, xargs, png2yuv)

-        #cmd += 'pnmtoy4m -Ip -F %s %s/*.png' % standard.fps_ratio(tvsys)

-

-    # TODO: Scale to correct target size using yuvscaler or similar

-

-    # Pipe image stream into mpeg2enc to encode

-    mpeg2enc = cli.Command('mpeg2enc')

-

-    # Anyways.

-    mpeg2enc.add('-I 0') # Progressive

-

-    # Bottom-first, determined in render/drawing.py::interlace_drawings()

-    if (interlaced):

-        mpeg2enc.add('--playback-field-order', 'b')  # Bottom-first field order

-        # conforming to drawing.py::interlace_drawings()

-

-    mpeg2enc.add('-v', '0',

-                 '-q' '3',

-                 '-o' '%s' % outfile)

-    # Format

-    if format == 'vcd':

-        mpeg2enc.add('--format', '1')

-    elif format == 'svcd':

-        mpeg2enc.add('--format', '4')

-    else:

-        mpeg2enc.add('--format', '8')

-    # Aspect ratio

-    if aspect == '16:9':

-        mpeg2enc.add('-a', '3')

-    elif aspect == '4:3':

-        mpeg2enc.add('-a', '2')

-

-    pipe.add(mpeg2enc)

-

-    pipe.run(capture=True)

-    pipe.get_output() # and wait :)

-

​

@@ -1,211 +0,0 @@

-"""Video encoding, ripping, and identification using ``mplayer``.

-"""

-

-__all__ = [

-    'encode',

-    'identify',

-    'rip_video',

-]

-

-from libtovid import log

-from libtovid import cli

-from libtovid.media import MediaFile

-from libtovid.backend import ffmpeg

-

-def encode(source, target, **kw):

-    """Encode a multimedia video using mencoder.

-

-        source

-            Input `~libtovid.media.MediaFile`

-        target

-            Output `~libtovid.media.MediaFile`

-        kw

-            Keyword arguments to customize encoding behavior

-

-    Supported keywords:

-

-        None yet

-

-    """

-    cmd = cli.Command('mencoder')

-    cmd.add(source.filename,

-            '-o', target.filename,

-            '-oac', 'lavc',

-            '-ovc', 'lavc',

-            '-of', 'mpeg')

-    # Format

-    cmd.add('-mpegopts')

-    if target.format in ['vcd', 'svcd']:

-        cmd.add('format=x%s' % target.format)

-    else:

-        cmd.add('format=dvd')

-

-    # FIXME: This assumes we only have ONE audio track.

-    if source.has_audio:

-        # Adjust audio sampling rate if necessary

-        if source.samprate != target.samprate:

-            log.info("Resampling needed to achieve %d Hz" % target.samprate)

-            cmd.add('-srate', target.samprate)

-            cmd.add('-af', 'lavcresample=%s' % target.samprate)

-        else:

-            log.info("No resampling needed, already at %d Hz" % target.samprate)

-

-    else:

-        log.info("No audio file, generating silence of %f seconds." % \

-                 source.length)

-        # Generate silence.

-        if target.format in ['vcd', 'svcd']:

-            audiofile = '%s.mpa' % target.filename

-        else:

-            audiofile = '%s.ac3' % target.filename

-        ffmpeg.encode_audio(source, audiofile, target)

-        # TODO: make this work, it's still not adding the ac3 file correctly.

-        cmd.add('-audiofile', audiofile)

-

-    # Video codec

-    if target.format == 'vcd':

-        lavcopts = 'vcodec=mpeg1video'

-    else:

-        lavcopts = 'vcodec=mpeg2video'

-    # Audio codec

-    lavcopts += ':acodec=%s' % target.acodec

-    lavcopts += ':abitrate=%s:vbitrate=%s' % \

-            (target.abitrate, target.vbitrate)

-    # Maximum video bitrate

-    lavcopts += ':vrc_maxrate=%s' % target.vbitrate

-    if target.format == 'vcd':

-        lavcopts += ':vrc_buf_size=327'

-    elif target.format == 'svcd':

-        lavcopts += ':vrc_buf_size=917'

-    else:

-        lavcopts += ':vrc_buf_size=1835'

-    # Set appropriate target aspect

-    if target.widescreen:

-        lavcopts += ':aspect=16/9'

-    else:

-        lavcopts += ':aspect=4/3'

-    # Pass all lavcopts together

-    cmd.add('-lavcopts', lavcopts)

-

-    # FPS

-    if target.tvsys == 'pal':

-        cmd.add('-ofps', '25/1')

-    elif target.tvsys == 'ntsc':

-        cmd.add('-ofps', '30000/1001') # ~= 29.97

-

-    # Scale/expand to fit target frame

-    if target.scale:

-        vfilter = 'scale=%s:%s' % target.scale

-        # Expand is not done unless also scaling

-        if target.expand != target.scale:

-            vfilter += ',expand=%s:%s' % target.expand

-        cmd.add('-vf', vfilter)

-

-    cmd.run()

-

-

-def identify(filename):

-    """Identify a video file using mplayer, and return a

-    `~libtovid.media.MediaFile` with the video's specifications.

-    """

-    # TODO: Raise an exception if the file couldn't be identified

-    # TODO: Infer aspect ratio

-

-    media = MediaFile(filename)

-

-    mp_dict = {}

-    # Use mplayer

-    cmd = cli.Command('mplayer',

-                  '-identify',

-                  '%s' % filename,

-                  '-vo', 'null',

-                  '-ao', 'null',

-                  '-frames', '1',

-                  '-channels', '6')

-    cmd.run(capture=True)

-

-    # Look for mplayer's "ID_..." lines and include each assignment in mp_dict

-    for line in cmd.get_output().splitlines():

-        log.debug(line)

-        if line.startswith("ID_"):

-            left, right = line.split('=')

-            mp_dict[left] = right.strip()

-

-    # Check for existence of streams

-    if 'ID_VIDEO_ID' in mp_dict:

-        media.has_video = True

-    else:

-        media.has_video = False

-    if 'ID_AUDIO_ID' in mp_dict:

-        media.has_audio = True

-    else:

-        media.has_audio = False

-

-    # Parse the dictionary and set appropriate values

-    for left, right in mp_dict.iteritems():

-        if left == "ID_VIDEO_WIDTH":

-            media.scale = (int(right), media.scale[1])

-        elif left == "ID_VIDEO_HEIGHT":

-            media.scale = (media.scale[0], int(right))

-        elif left == "ID_VIDEO_FPS":

-            media.fps = float(right)

-        elif left == "ID_VIDEO_FORMAT":

-            media.vcodec = right

-        elif left == "ID_VIDEO_BITRATE":

-            media.vbitrate = int(right) / 1000

-        elif left == "ID_AUDIO_CODEC":

-            media.acodec = right

-        elif left == "ID_AUDIO_FORMAT":

-            pass

-        elif left == "ID_AUDIO_BITRATE":

-            media.abitrate = int(right) / 1000

-        elif left == "ID_AUDIO_RATE":

-            media.samprate = int(right)

-        elif left == "ID_AUDIO_NCH":

-            media.channels = right

-        elif left == 'ID_LENGTH':

-            media.length = float(right)

-    media.expand = media.scale

-

-    # Fix mplayer's audio codec naming for ac3 and mp2

-    if media.acodec == "8192":

-        media.acodec = "ac3"

-    elif media.acodec == "80":

-        media.acodec = "mp2"

-    # Fix mplayer's video codec naming for mpeg1 and mpeg2

-    if media.vcodec == "0x10000001":

-        media.vcodec = "mpeg1"

-    elif media.vcodec == "0x10000002":

-        media.vcodec = "mpeg2"

-    return media

-

-

-

-

-def rip_video(source, yuvfile, target):

-    """Rip video to the given yuv4mpeg file.

-

-        source

-            Input `~libtovid.media.MediaFile`

-        yuvfile

-            File to put ripped video in

-        target

-            Output `~libtovid.media.MediaFile`

-

-    """

-    # TODO: Custom mplayer options, subtitles, interlacing,

-    # corresp.  to $MPLAYER_OPT, $SUBTITLES, $VF_PRE/POST, $YUV4MPEG_ILACE,

-    # etc.

-    cmd = cli.Command('mplayer')

-    cmd.add(source.filename)

-    cmd.add('-vo', 'yuv4mpeg:file=%s' % yuvfile)

-    cmd.add('-nosound', '-benchmark', '-noframedrop')

-    # TODO: Support subtitles. For now, use default tovid behavior.

-    cmd.add('-noautosub')

-    if target.scale:

-        cmd.add('-vf', 'scale=%s:%s' % target.scale)

-    if target.expand > target.scale:

-        cmd.add('-vf-add', 'expand=%s:%s' % target.expand)

-    # Run the command to rip the video

-    cmd.run(background=True)

-

​

@@ -1,38 +0,0 @@

-"""Multiplexing using ``mplex``.

-"""

-

-__all__ = [

-    'mux',

-]

-

-from libtovid import cli

-

-def mux(vstream, astream, target):

-    """Multiplex audio and video stream files to the given target.

-

-        vstream

-            Filename of MPEG video stream

-        astream

-            Filename of MP2/AC3 audio stream

-        target

-            Profile of output file

-

-    """

-    cmd = cli.Command('mplex')

-    format = target.format

-    if format == 'vcd':

-        cmd.add('-f', '1')

-    elif format == 'dvd-vcd':

-        cmd.add('-V', '-f', '8')

-    elif format == 'svcd':

-        cmd.add('-V', '-f', '4', '-b', '230')

-    elif format == 'half-dvd':

-        cmd.add('-V', '-f', '8', '-b', '300')

-    elif format == 'dvd':

-        cmd.add('-V', '-f', '8', '-b', '400')

-    # elif format == 'kvcd':

-    #   cmd += ' -V -f 5 -b 350 -r 10800 '

-    cmd.add(vstream, astream, '-o', target.filename)

-    # Run the command to multiplex the streams

-    cmd.run()

-

​

@@ -1,180 +0,0 @@

-"""This module is for adding subtitles to MPEG video files using spumux.

-

-Defined here are two functions for adding subtitles to an MPEG file:

-

-    `add_subpictures`

-        Add image files (``.png``)

-    `add_subtitles`

-        Add subtitle files (``.sub``, ``.srt`` etc.)

-

-Use these if you just want to add subpictures or subtitles, and don't want

-to think much about the XML internals.

-"""

-

-__all__ = [

-    'add_subpictures',

-    'add_subtitles',

-]

-

-import os

-from libtovid import util

-from libtovid import xml

-from libtovid import cli

-from libtovid.backend import mplayer

-

-# spumux XML elements and valid attributes

-#

-# subpictures

-# stream

-# textsub

-#     ['filename',

-#     'characterset',

-#     'fontsize',

-#     'font',

-#     'horizontal-alignment',

-#     'vertical-alignment',

-#     'left-margin',

-#     'right-margin',

-#     'subtitle-fps',

-#     'movie-fps',

-#     'movie-width',

-#     'movie-height']

-# button

-#     ['name',

-#     'x0', 'y0', # Upper-left corner, inclusively

-#     'x1', 'y1', # Lower-right corner, exclusively

-#     'up', 'down', 'left', 'right']

-# action

-#     ['name']

-# spu

-#     ['start',

-#     'end',

-#     'image',

-#     'highlight',

-#     'select',

-#     'transparent',   # color code

-#     'force',         # 'yes' (force display, required for menus)

-#     'autooutline',   # 'infer'

-#     'outlinewidth',

-#     'autoorder',     # 'rows' or 'columns'

-#     'xoffset',

-#     'yoffset']

-

-def _get_xml(textsub_or_spu):

-    """Return an XML string for the given Textsub or Spu element.

-    """

-    subpictures = xml.Element('subpictures')

-    stream = subpictures.add('stream')

-    stream.add_child(textsub_or_spu)

-    return str(subpictures)

-

-

-def _get_xmlfile(textsub_or_spu):

-    """Write spumux XML file for the given Textsub or Spu element, and

-    return the written filename.

-    """

-    xmldata = _get_xml(textsub_or_spu)

-    xmlfile = open(util.temp_file(suffix=".xml"), 'w')

-    xmlfile.write(xmldata)

-    xmlfile.close()

-    return xmlfile.name

-

-

-def _mux_subs(subtitle, movie_filename, stream_id=0):

-    """Run spumux to multiplex the given subtitle with an ``.mpg`` file.

-

-        subtitle

-            Textsub or Spu element

-        movie_filename

-            Name of an ``.mpg`` file to multiplex subtitle into

-        stream_id

-            Stream ID number to pass to spumux

-    """

-    # Create XML file for subtitle element

-    xmlfile = _get_xmlfile(subtitle)

-    # Create a temporary .mpg for the subtitled output

-    #base_dir = os.path.dirname(movie_filename)

-    subbed_filename = util.temp_file(suffix=".mpg")

-    # spumux xmlfile < movie_filename > subbed_filename

-    spumux = cli.Command('spumux', '-s%s' % stream_id,  xmlfile.name)

-    spumux.run_redir(movie_filename, subbed_filename)

-    spumux.wait()

-

-    # Remove old file

-    os.remove(movie_filename)

-    # Rename temporary file to new file

-    os.rename(subbed_filename, movie_filename)

-    # Remove the XML file

-    os.remove(xmlfile.name)

-

-

-def add_subpictures(movie_filename, select, image=None, highlight=None):

-    """Adds ``.png`` subpictures to an ``.mpg`` video file to create a DVD menu.

-

-        select

-            ``.png`` filename shown for the navigational selector or "cursor"

-        image

-            ``.png`` filename shown for non-selected regions

-        highlight

-            ``.png`` filename shown when "enter" is pressed

-

-    All images must be indexed, 4-color, transparent, non-antialiased PNG.

-    Button regions are auto-inferred.

-    """

-    spu = xml.Element('spu')

-    spu.set(start='0',

-            force='yes',

-            select=select,

-            image=image,

-            highlight=highlight)

-    # TODO Find a good default outlinewidth

-    spu.set(autooutline='infer', outlinewidth='10')

-    # TODO: Support explicit button regions

-    _mux_subs(spu, movie_filename)

-

-

-def add_subtitles(movie_filename, sub_filenames):

-    """Adds one or more subtitle files to an ``.mpg`` video file.

-

-        movie_filename

-            Name of ``.mpg`` file to add subtitles to

-        sub_filenames

-            Filename or list of filenames of subtitle

-            files to include (``.sub``, ``.srt`` etc.)

-

-    """

-    infile = mplayer.identify(movie_filename)

-    width, height = infile.scale

-

-    # Convert sub_filenames to list if necessary

-    if type(sub_filenames) == str:

-        sub_filenames = [sub_filenames]

-    # spumux each subtitle file with its own stream ID

-    for stream_id, sub_filename in enumerate(sub_filenames):

-        # <textsub attribute="value" .../>

-        textsub = xml.Element('textsub')

-        textsub.set(movie_fps=infile.fps,

-                    movie_width=width,

-                    movie_height=height,

-                    filename=sub_filename)

-        _mux_subs(textsub, movie_filename, stream_id)

-

-

-

-if __name__ == '__main__':

-    print("spumux XML examples")

-

-    print("Subpicture example:")

-    spu = xml.Element('spu')

-    spu.add('button', name='but1', down='but2')

-    spu.add('button', name='but2', up='but1')

-    print(_get_xml(spu))

-

-    print("Text subtitle example:")

-    textsub = xml.Element('textsub')

-    textsub.set(filename='foo.sub',

-                fontsize=14.0,

-                font="Luxi Mono")

-    print(_get_xml(textsub))

-

-

​

@@ -1,119 +0,0 @@

-"""Video frame ripping and video identification using ``transcode``.

-"""

-

-# Sample output from tcprobe:

-#

-# [tcprobe] RIFF data, AVI video

-# [avilib] V: 24.000 fps, codec=DIVX, frames=15691, width=1024, height=576

-# [avilib] A: 48000 Hz, format=0x2000, bits=0, channels=5, bitrate=448 kbps,

-# [avilib]    10216 chunks, 36614144 bytes, CBR

-# [tcprobe] summary for Elephants_1024.avi, (*) = not default, 0 = not

-# detected

-# import frame size: -g 1024x576 [720x576] (*)

-#        frame rate: -f 24.000 [25.000] frc=0 (*)

-#       audio track: -a 0 [0] -e 48000,0,5 [48000,16,2] -n 0x2000 [0x2000] (*)

-#                    bitrate=448 kbps

-#            length: 15691 frames, frame_time=41 msec, duration=0:10:53.790

-

-__all__ = [

-    'identify',

-    'rip_frames',

-]

-

-import os, re, glob

-from libtovid import log

-from libtovid import cli

-from libtovid.media import MediaFile

-

-def identify(filename):

-    """Identify a video file using transcode (tcprobe), and return a

-    `~libtovid.media.MediaFile` with the video's specifications.

-    """

-    result = MediaFile(filename)

-

-    cmd = cli.Command('tcprobe', '-i', filename)

-    cmd.run(capture=True)

-    output = cmd.get_output()

-

-    video_line = re.compile('V: '

-        '(?P<fps>[\d.]+) fps, '

-        'codec=(?P<vcodec>[^,]+), '

-        'frames=\d+, '

-        'width=(?P<width>\d+), '

-        'height=(?P<height>\d+)')

-

-    audio_line = re.compile('A: '

-        '(?P<samprate>\d+) Hz, '

-        'format=(?P<acodec>[^,]+), '

-        'bits=\d+, '

-        'channels=(?P<channels>[^,]+), '

-        'bitrate=(?P<abitrate>\d+) kbps')

-

-    for line in output.split('\n'):

-        if 'V: ' in line:

-            match = video_line.search(line)

-            result.fps = float(match.group('fps'))

-            result.vcodec = match.group('vcodec')

-            result.scale = (int(match.group('width')),

-                            int(match.group('height')))

-            result.expand = result.scale

-

-        elif 'A: ' in line:

-            match = audio_line.search(line)

-            result.acodec = match.group('acodec')

-            result.samprate = int(match.group('samprate'))

-            result.abitrate = int(match.group('abitrate'))

-            result.channels = int(match.group('channels'))

-

-    return result

-

-

-def rip_frames(media, out_dir, frames='all', size=(0, 0)):

-    """Extract frame images from a `~libtovid.media.MediaFile` and return a

-    list of frame image files.

-

-        media

-            `~libtovid.media.MediaFile` to extract images from

-        out_dir

-            Directory where output images should be stored; images are saved