Merge commit 'ichthyo/scons'

.gitignore

@@ -1,12 +1,9 @@
 /wiki/backups/*
 *~
-a.out
-semantic.cache
-aclocal.m4
-Makefile
-Makefile.in
-autom4te*
-config.*
-configure
 *.tar.*
-build/*
+.sconf_temp
+.sconf_temp/*
+.sconsign.dblite
+Buildhelper.pyc
+optcache
+

Buildhelper.py

@@ -0,0 +1,152 @@
+# -*- python -*-
+##
+## Buildhelper.py  -  helpers, custom builders, for SConstruct
+##
+
+#  Copyright (C)         CinelerraCV
+#    2007,               Hermann Vosseler <Ichthyostega@web.de>
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License as
+#  published by the Free Software Foundation; either version 2 of 
+#  the License, or (at your option) any later version.
+#
+#  This program 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 General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+#####################################################################
+
+import os
+import sys
+import fnmatch
+import re
+import tarfile
+
+
+
+#
+# Common Helper Functions
+#
+def isCleanupOperation(env):
+    return env.GetOption('clean')
+
+def isHelpRequest():
+    ''' this is a hack: SCons does all configure tests even if only
+        the helpmessage is requested. SCons doesn't export the
+        help option for retrieval by env.GetOption(), 
+        so we scan the commandline directly. 
+    '''
+    return '-h' in sys.argv or '--help' in sys.argv
+
+
+
+def srcSubtree(env,tree,isShared=False, **args):
+    ''' convienience wrapper: scans the given subtree, which is
+        to be located within $SRCDIR, find all source files and
+        declare them as Static or SharedObjects for compilation
+    '''
+    root = env.subst('$SRCDIR/%s' % tree)  # expand $SRCDIR
+    if isShared:
+        builder = lambda f: env.SharedObject(f, **args)
+    else: 
+        builder = lambda f: env.Object(f, **args)
+        
+    return [builder(f) for f in scanSrcSubtree(root)] 
+
+
+
+SRCPATTERNS = ['*.c','*.Cpp','*.cc']
+
+def scanSrcSubtree(root):
+    ''' scan the given subtree for source filesnames 
+        (python generator function)
+    '''
+    for (dir,_,files) in os.walk(root):
+        if dir.startswith('./'):
+            dir = dir[2:]
+        for p in SRCPATTERNS:
+            for f in fnmatch.filter(files, p):
+                yield os.path.join(dir,f)
+
+
+
+
+def Tarball(env,location,dirs,suffix=''):
+    ''' Custom Command: create Tarball of some subdirs
+        location: where to create the tar (optionally incl. filename.tar.gz)
+        suffix: (optional) suffix to include in the tar name
+        dirs: directories to include in the tar
+        
+        This is a bit of a hack, because we want to be able to include arbitrary dirctories,
+        without creating new dependencies on those dirs. Esp. we want to tar the source tree
+        prior to compiling. Solution is 
+         - use the Command-Builder, but pass all target specifications as custom build vars
+         - create a pseudo-target located in the parent directory (not built by default)
+    '''
+    targetID    = '../extern-tar%s' % suffix
+    versionID   = env['VERSION']
+    defaultName = 'cinelerra%s_%s' % (suffix, versionID)
+    nameprefix  = 'cinelerra-%s/' %  (versionID)
+    location    = env.subst(location)
+    dirs        = env.subst(dirs)
+    return env.Command(targetID,None, createTarball, 
+                       location=location, defaultName=defaultName, dirs=dirs, nameprefix=nameprefix)
+
+
+def createTarball(target,source,env):
+    ''' helper, builds the tar using the python2.3 tarfil lib.
+        This allows us to prefix all paths, thus moving the tree
+        into a virtual subdirectory containing the Version number,
+        as needed by common packaging systems.
+    '''
+    name = getTarName( location = env['location']
+                     , defaultName = env['defaultName'])
+    targetspec = env['dirs']
+    nameprefix = env['nameprefix'] or ''
+    print 'Running: tar -czf %s %s ...' % (name,targetspec)
+    if os.path.isfile(name):
+        os.remove(name)
+    tar = tarfile.open(name,'w:gz')
+    for name in targetspec.split():
+        tar.add(name,nameprefix+name)
+    tar.close()
+#
+# old version using shell command:
+#    
+#    cmd = 'tar -czf %s %s' % (name,targetspec)
+#    print 'running ', cmd, ' ... '
+#    pipe = os.popen (cmd)
+#    return pipe.close ()
+
+
+
+
+def getTarName(location, defaultName):
+    ''' create a suitable name for the tarball.
+        - if location contains a name (*.tar.gz) then use this
+        - otherwise append the defaultName to the specified dir
+    '''  
+    spec = os.path.abspath(location)
+    (head,tail) = os.path.split(spec)
+    if not os.path.isdir(head):
+        print 'Target dir "%s" for Tar doesn\'t exist.' % head
+        Exit(1)
+    mat = re.match(r'([\w\.\-\+:\~]+)\.((tar)|(tar\.gz)|(tgz))', tail)
+    if mat:
+        name = mat.group(1)
+        ext  = '.'+mat.group(2)
+    else:
+        ext = '.tar.gz'
+        if os.path.isdir(spec):
+            head = spec
+            name = defaultName
+        else:
+            name = tail
+    return os.path.join(head,name+ext)
+            
+

SConstruct

@@ -0,0 +1,226 @@
+# -*- python -*-
+##
+## SConstruct  -  SCons based build-sytem for Cinelerra
+##
+
+#  Copyright (C)         CinelerraCV
+#    2007,               Hermann Vosseler <Ichthyostega@web.de>
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License as
+#  published by the Free Software Foundation; either version 2 of 
+#  the License, or (at your option) any later version.
+#
+#  This program 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 General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+#####################################################################
+
+import os
+from Buildhelper import *
+
+#-----------------------------------Configuration
+OPTIONSCACHEFILE = 'optcache' 
+CUSTOPTIONSFILE  = 'custom-options'
+SRCDIR           = 'src'
+BINDIR           = 'src/bin'
+VERSION          = '3+alpha.01'
+#-----------------------------------Configuration
+
+# NOTE: scons -h for help.
+# Read more about the SCons build system at: http://www.scons.org
+# Basically, this script just /defines/ the components and how they
+# fit together. SCons will derive the necessary build steps.
+
+
+
+
+#####################################################################
+
+def setupBasicEnvironment():
+    ''' define cmdline options, build type decisions
+    '''
+    EnsurePythonVersion(2,3)
+    EnsureSConsVersion(0,96,90)
+    
+    opts = defineCmdlineOptions() 
+ 
+    env = Environment(options=opts) 
+    env.Replace( VERSION=VERSION
+               , SRCDIR=SRCDIR
+               , BINDIR=BINDIR
+               , CPPPATH=SRCDIR   # used to find includes
+               )
+    appendCppDefine(env,'DEBUG','DEBUG')
+    appendCppDefine(env,'OPENGL','USE_OPENGL')
+    appendVal(env,'ARCHFLAGS', 'CPPFLAGS')   # for both C and C++
+    appendVal(env,'OPTIMIZE', 'CPPFLAGS', val=' -O3')
+    
+    prepareOptionsHelp(opts,env)
+    opts.Save(OPTIONSCACHEFILE, env)
+    return env
+
+def appendCppDefine(env,var,cppVar):
+    if env[var]:
+        env.Append(CPPDEFINES = {cppVar: env[var]})
+
+def appendVal(env,var,targetVar,val=None):
+    if env[var]:
+        env.Append( **{targetVar: val or env[var]})
+
+
+
+def defineCmdlineOptions():
+    ''' current options will be persisted in a options cache file.
+        you may define custom options in a separate file. 
+        Commandline will override both.
+    '''
+    opts = Options([OPTIONSCACHEFILE, CUSTOPTIONSFILE])
+    opts.AddOptions(
+        ('ARCHFLAGS', 'Set architecture-specific compilation flags (passed literally to gcc)','')
+        ,BoolOption('DEBUG', 'Build with debugging information and no optimizations', False)
+        ,BoolOption('OPTIMIZE', 'Build with strong optimization (-O3)', False)
+        ,BoolOption('OPENGL', 'Include support for OpenGL preview rendering', False)
+#       ,EnumOption('DIST_TARGET', 'Build target architecture', 'auto', 
+#                   allowed_values=('auto', 'i386', 'i686', 'x86_64' ), ignorecase=2)
+        ,PathOption('DESTDIR', 'Installation dir prefix', '/usr/local')
+        ,PathOption('SRCTAR', 'Create source tarball prior to compiling', '..', PathOption.PathAccept)
+        ,PathOption('DOCTAR', 'Create tarball with dev documentaionl', '..', PathOption.PathAccept)
+     )
+
+    return opts
+
+
+
+def prepareOptionsHelp(opts,env):
+    prelude = '''
+USAGE:   scons [-c] [OPTS] [key=val,...] [TARGETS]
+     Build and optionally install Cinelerra.
+     Without specifying any target, just the (re)build target will run.
+     Add -c to the commandline to clean up anything a given target would produce
+
+Special Targets:
+     build   : just compile and link
+     install : install created artifacts at PREFIX
+     src.tar : create source tarball
+     doc.tar : create developer doc tarball
+     tar     : create all tarballs
+
+Configuration Options:
+'''
+    Help(prelude + opts.GenerateHelpText(env))
+
+
+
+
+def configurePlatform(env):
+    ''' locate required libs.
+        setup platform specific options.
+        Abort build in case of failure.
+    '''
+    conf = Configure(env)
+    # run all configuration checks in the current env
+    
+    # Checks for prerequisites ------------
+    if not conf.CheckLibWithHeader('m', 'math.h','C'):
+        print 'Did not find math.h / libm, exiting.'
+        Exit(1)
+    
+    if not conf.CheckCXXHeader('boost/config.hpp'):
+        print 'We need the C++ boost-lib.'
+        Exit(1)
+    
+    if not conf.CheckCXXHeader('boost/shared_ptr.hpp'):
+        print 'We need boost::shared_ptr (shared_ptr.hpp).'
+        Exit(1)
+        
+    # create new env containing the finished configuration
+    return conf.Finish()
+
+
+
+def definePackagingTargets(env, artifacts):
+    ''' build operations and targets to be done /before/ compiling.
+        things like creating a source tarball or preparing a version header.
+    '''
+    t = Tarball(env,location='$SRCTAR',dirs='$SRCDIR')
+    artifacts['src.tar'] = t
+    env.Alias('src.tar', t)
+    env.Alias('tar', t)
+
+    t =  Tarball(env,location='$DOCTAR',suffix='-doc',dirs='admin doc wiki uml tests')
+    artifacts['doc.tar'] = t
+    env.Alias('doc.tar', t)
+    env.Alias('tar', t)
+
+
+
+def defineBuildTargets(env, artifacts):
+    ''' define the source file/dirs comprising each artifact to be built.
+        setup sub-environments with special build options if necessary.
+        We use a custom function to declare a whole tree of srcfiles. 
+    '''
+    cinobj = ( srcSubtree(env,'backend') 
+             + srcSubtree(env,'proc')
+             + env.Object('$SRCDIR/main.cpp')
+             )
+    plugobj = srcSubtree(env,'plugin', isShared=True)
+    
+    artifacts['cinelerra'] = env.Program('$BINDIR/cinelerra', cinobj)
+    artifacts['plugins']   = env.SharedLibrary('$BINDIR/cinelerra-plugin', plugobj)
+    
+    # call subdir SConscript(s) for independent components
+    SConscript(dirs=[SRCDIR+'/tool'], exports='env artifacts')
+    
+
+
+def defineInstallTargets(env, artifacts):
+    ''' define install locations and cleanup after the build.
+        define alias targets to trigger the installing.
+    '''
+    env.Install(dir = '$DESTDIR/bin', source=artifacts['cinelerra'])
+    env.Install(dir = '$DESTDIR/lib', source=artifacts['plugins'])
+    env.Install(dir = '$DESTDIR/bin', source=artifacts['tools'])
+    
+    ib = env.Alias('install-bin', '$DESTDIR/bin')
+    il = env.Alias('install-lib', '$DESTDIR/lib')
+    env.Alias('install', [ib, il])
+    
+    env.Alias('build', '$BINDIR')
+    env.Default('build')
+    # additional files to be cleaned when cleaning 'build'
+    env.Clean ('build', [ 'scache.conf', '.sconf_temp', '.sconsign.dblite', 'config.log'])
+
+#####################################################################
+
+
+
+
+
+### === MAIN === ####################################################
+
+
+env = setupBasicEnvironment()
+
+if not (isCleanupOperation(env) or isHelpRequest()):
+    env = configurePlatform(env)
+    
+artifacts = {}
+# the various things we build. 
+# Each entry actually is a SCons-Node list.
+# Passing these entries to other builders defines dependencies.
+# 'cinelerra'   : the App
+# 'plugins'     : plugin shared lib
+# 'tools'       : small tool applications (e.g mpegtoc)
+# 'src,tar'     : source tree as tarball (without doc)
+# 'doc.tar'     : uml model, wiki, dev docu (no src)
+
+definePackagingTargets(env, artifacts)
+defineBuildTargets(env, artifacts)
+defineInstallTargets(env, artifacts)
+

src/main.cpp

@@ -0,0 +1,31 @@
+/*
+  main.cpp  -  start the Cinelerra Application
+
+  Copyright (C)         CinelerraCV
+    2007,               Christian Thaeter <ct@pipapo.org>
+                        Hermann Vosseler <Ichthyostega@web.de>
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License as
+  published by the Free Software Foundation; either version 2 of the
+  License, or (at your option) any later version.
+
+  This program 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 General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+
+
+#include <stdio.h>
+
+int main(int argc, char* argv[])
+  {
+    printf("hello cinelerra again\n");
+    return 0;
+  }

src/plugin/helloplugin.c

@@ -0,0 +1,12 @@
+/*
+ * hello.c - demonstrates how to build a standalone tool (C source) 
+ *           integrated into the SCons based build system of Cinelerra
+ */
+
+#include <stdio.h>
+
+int main(int argc, char* argv[])
+  {
+    printf("hello cinelerra world");
+    return 0;
+  }

src/tool/DIR_INFO

@@ -0,0 +1 @@
+source code of supplementary tools to be built alongside with Cinelerra

src/tool/SConscript

@@ -0,0 +1,10 @@
+# -*- python -*-
+##
+## SConscript  -  SCons buildscript for tool subdirectory (called by SConstruct)
+##
+
+Import('env','artifacts')
+
+# build the ubiquitous Hello World application (note: C source)
+artifacts['tools'] = env.Program('#$BINDIR/hello-world','hello.c')
+

src/tool/hello.c

@@ -0,0 +1,12 @@
+/*
+ * hello.c - demonstrates how to build a standalone tool (C source) 
+ *           integrated into the SCons based build system of Cinelerra
+ */
+
+#include <stdio.h>
+
+int main(int argc, char* argv[])
+  {
+    printf("hello cinelerra world");
+    return 0;
+  }