Initial alpha release for evaluation by invite-only community.

Author: jminor

.gitignore

@@ -0,0 +1,3 @@
+*.swp
+*.pyc
+build*

EULA.pdf

@@ -0,0 +1,23 @@
+# run all the unit tests
+test:
+	python2.7 -m unittest discover tests
+
+# run all the unit tests, stopping at the first failure
+test_first_fail:
+	python2.7 -m unittest discover tests --failfast
+
+# skip the timecode test that takes forever
+fast_test:
+	env OTIO_FAST_TEST=1 python2.7 -m unittest discover tests
+
+# remove pyc files
+clean:
+	rm */*.pyc */*/*.pyc
+
+# conform all files to pep8 -- WILL CHANGE FILES IN PLACE
+autopep8:
+	find . -name "*.py" | xargs autopep8 --aggressive --in-place -r
+
+# run the codebase through pep8
+pep8:
+	@find . -name "*.py" | xargs pep8

Makefile

@@ -0,0 +1,102 @@
+OpenTimelineIO
+==============
+
+PRE-RELEASE NOTICE
+-----------------
+
+We intend to release OpenTimelineIO as an open source project. Prior to
+release, a few people (like you) have early access to the project. Please see
+the contact section at the bottom if you have questions about this.
+
+Overview
+--------
+
+OpenTimelineIO is an interchange format and API for editorial cut information.
+OTIO is not a container format for media, rather it contains information about
+the order and length of cuts and references to external media.
+
+OTIO includes both a file format and an API for manipulating that format.  It
+also includes a plugin architecture for writing adapters to convert
+from/to existing editorial timeline formats.  It also implements a dependency-
+less library for dealing strictly with time, `opentime`.
+
+You can provide adapters for your video editing tool or pipeline as needed.
+Each adapter allows for import/export between that proprietary tool and the
+OpenTimelineIO format.
+
+Use Cases
+---------
+
+- I have a timeline in Adobe Premiere, and I want to bring that cut into my
+    in-house animation system.
+- I have a timeline in Avid Media Composer, and my Producer wants to know a
+     full list of the media I'm using.
+- I am about to render a bunch of shots & I want to make sure my frame ranges
+    match what Editorial is asking for (not too long or too short).
+- The Editor just added some cross dissolves and I need to know how many more
+     frames (at head or tail) of which shots need to be rendered.
+- Legal needs a list of all the audio we're using (music, effects, dialogue) in
+     the current cut.
+- TDs/Animators want to get a cut from Editorial for reference, and then splice
+     their updated renders/recordings into that cut.
+- Editorial is working with proxy media (QuickTime, MXF, etc.) and I want to
+    gather all the EXRs that correspond with that & bring those into Nuke.
+
+Architecture
+------------
+
+TODO: INSERT POINTER TO CONCEPTUAL ARCHITECTURE DOCUMENT
+
+Adapters
+--------
+
+OpenTimelineIO supports, or plans to support, conversion adapters for these
+formats:
+
+### Final Cut Pro FCPXML Document ###
+
+- TODO: Not yet implemented
+- https://developer.apple.com/library/mac/documentation/FinalCutProX/Reference/FinalCutProXXMLFormat/Introduction/Introduction.html
+
+### Adobe Premiere Project ###
+
+- TODO: Not yet implemented
+- TODO: Documentation?
+
+### CMX3600 EDL ###
+
+- Limited support
+- http://xmil.biz/EDL-X/CMX3600.pdf
+
+### Avid AAF ###
+
+- TODO: Not yet implemented
+- http://www.amwa.tv/downloads/specifications/aafobjectspec-v1.1.pdf
+- http://www.amwa.tv/downloads/specifications/aafeditprotocol.pdf
+
+Installing
+----------
+
+run:
+```
+python setup.py install
+```
+
+To build and install the project.
+
+Makefile
+--------
+
+Even though the project is python, we provide a makefile with some utility targets.  These include targets for running unit tests and for running pep8/autopep8 to conform to style guide.
+
+Developing
+----------
+
+Currently the code base is written against python2.7.  Before committing please run your changes through pep8/autopep8.
+
+Contact
+-------
+
+For more information, please visit http://opentimeline.io/
+or https://github.com/PixarAnimationStudios/OpenTimelineIO
+

README.md

@@ -0,0 +1,43 @@
+#!/usr/bin/env python2.7
+
+import argparse
+
+import opentimelineio as otio
+
+__doc__ = """ Print the contents of an OTIO file to stdout.  """
+
+
+def _parsed_args():
+    """ parse commandline arguments with argparse """
+
+    parser = argparse.ArgumentParser(
+        description=__doc__,
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter
+    )
+    parser.add_argument(
+        'filepath',
+        type=str,
+        nargs='+',
+        help='files to print the contents of'
+    )
+
+    return parser.parse_args()
+
+
+def _cat_otio_file(fpath):
+    """ use the pretty print string adapter on the file.  """
+
+    adapter = otio.adapters.from_name("pretty_print_string")
+    return adapter.write_to_string(otio.adapters.read_from_file(fpath))
+
+
+def main():
+    """Parse arguments and call _cat_otio_file."""
+    args = _parsed_args()
+
+    for fpath in args.filepath:
+        print("fpath: {}".format(fpath))
+        print(_cat_otio_file(fpath))
+
+if __name__ == '__main__':
+    main()

bin/otiocat.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python2.7
+
+# python
+import argparse
+import sys
+
+import opentimelineio as otio
+
+__doc__ = """ Python wrapper around OTIO to convert timeline files between \
+formats.
+
+Available adapters: {}
+""".format(otio.adapters.available_adapter_names())
+
+
+def _parsed_args():
+    """ parse commandline arguments with argparse """
+
+    parser = argparse.ArgumentParser(
+        description=__doc__,
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter
+    )
+    parser.add_argument(
+        '-i',
+        '--input',
+        type=str,
+        required=True,
+        help='path to input file',
+    )
+    parser.add_argument(
+        '-o',
+        '--output',
+        type=str,
+        required=True,
+        help='path to output file',
+    )
+    parser.add_argument(
+        '-I',
+        '--input-adapter',
+        type=str,
+        default=None,
+        help="Instead of inferring the adapter to use, pick from the list.",
+    )
+    parser.add_argument(
+        '-O',
+        '--output-adapter',
+        type=str,
+        default=None,
+        help="Instead of inferring the adapter to use, pick from the list.",
+    )
+    parser.add_argument(
+        '-T',
+        '--tracks',
+        type=str,
+        default=None,
+        help="Pick one or more tracks, by 0-based index, separated by commas.",
+    )
+
+    return parser.parse_args()
+
+
+def main():
+    """ Parse arguments and convert the files. """
+
+    args = _parsed_args()
+
+    in_adapter = args.input_adapter
+    if in_adapter is None:
+        otio.adapters.from_filepath(args.input)
+
+    out_adapter = args.output_adapter
+    if out_adapter is None:
+        otio.adapters.from_filepath(args.output)
+
+    result_tl = otio.adapters.read_from_file(args.input, in_adapter)
+
+    if args.tracks:
+        result_tracks = []
+        for track in args.tracks.split(","):
+            result_tracks.append(result_tl.tracks[int(track)])
+        result_tl.tracks = result_tracks
+
+    otio.adapters.write_to_file(result_tl, args.output, out_adapter)
+
+if __name__ == '__main__':
+    try:
+        main()
+    except otio.exceptions.OTIOError as err:
+        sys.stderr.write("ERROR: " + str(err) + "\n")
+        sys.exit(1)

bin/otioconvert.py

@@ -0,0 +1,126 @@
+#!/usr/bin/env python
+
+"""
+Example OTIO script that reads a timeline and then relinks clips
+to movie files found in a given folder, based on matching names.
+
+Demo:
+
+% ls -1R
+editorial_cut.otio
+media/
+    shot1.mov
+    shot17.mov
+    shot99.mov
+
+% conform.py -i editorial_cut.otio -f media -o conformed.otio
+Relinked 3 clips to new media.
+Saved conformed.otio with 100 clips.
+
+% diff editorial_cut.otio conformed.otio
+...
+
+"""
+
+import argparse
+import glob
+import os
+
+import opentimelineio as otio
+
+
+def parse_args():
+    """ parse arguments out of sys.argv """
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        '-i',
+        '--input',
+        type=str,
+        required=True,
+        help='Timeline file(s) to read. Any format supported by OTIO will'
+        ' work.'
+    )
+    parser.add_argument(
+        '-f',
+        '--folder',
+        type=str,
+        required=True,
+        help='Folder to look for media in.'
+    )
+    parser.add_argument(
+        '-o',
+        '--output',
+        type=str,
+        required=True,
+        help="Timeline file to write out."
+    )
+    return parser.parse_args()
+
+
+def _find_matching_media(name, folder):
+    """ Look for media with this name in this folder. """
+
+    # In this case we're looking in the filesystem.
+    # In your case, you might want to look in your asset management system
+    # and you might want to use studio-specific metadata in the clip instead
+    # of just the clip name.
+    # Something like this:
+    # shot = asset_database.find_shot(clip.metadata['mystudio']['shotID'])
+    # new_media = shot.latest_render(format='mov')
+
+    matches = glob.glob("{0}/{1}.*".format(folder, name))
+    matches = map(os.path.abspath, matches)
+
+    if len(matches) == 0:
+        # print "DEBUG: No match for clip '{0}'".format(name)
+        return None
+    if len(matches) == 1:
+        return matches[0]
+    else:
+        print "WARNING: {0} matches found for clip '{1}', using '{2}'".format(
+            len(matches),
+            name,
+            matches[0]
+        )
+        return matches[0]
+
+
+def _conform_timeline(timeline, folder):
+    """ Look for replacement media for each clip in the given timeline.
+    The clips are relinked in place if media with a matching name is found.
+    """
+
+    count = 0
+
+    for clip in timeline.each_clip():
+        # look for a media file that matches the clip's name
+        new_path = _find_matching_media(clip.name, folder)
+
+        # if no media is found, keep going
+        if not new_path:
+            continue
+
+        # if we found one, then relink to the new path
+        clip.media_reference = otio.media_reference.External(
+            target_url="file://" + new_path,
+            available_range=None    # we don't know the available range
+        )
+        count += 1
+
+    return count
+
+
+def main():
+    args = parse_args()
+
+    timeline = otio.adapters.read_from_file(args.input)
+    count = _conform_timeline(timeline, args.folder)
+    print "Relinked {0} clips to new media.".format(count)
+    otio.adapters.write_to_file(timeline, args.output)
+    print "Saved {} with {} clips.".format(
+        args.output,
+        len(list(timeline.each_clip()))
+    )
+
+if __name__ == '__main__':
+    main()