Merge lp:~zequence/ubuntu/trusty/ardour3/fix-for-1450992 into lp:ubuntu/trusty/ardour3

[Kaj Ailomaa]

Fix for bug 1450992.

This is the last release of ardour3.

[Micah Gersten (micahg)]

Rejecting in favor of a full backport SRU

review: Disapprove

Unmerged revisions

15. By Adrian Knoth on 2014-12-04

Fix MIDI data loss when editing (Closes: #772118)

14. By Adrian Knoth on 2014-10-03

Reupload with waf fixes from 3.5.380~dfsg-2 and -3

13. By Felipe Sateler on 2014-07-11

Prevent build failures in slower architectures by
forcing waf logging to stdout instead of stderr.

12. By Felipe Sateler on 2014-06-16

* Team upload.
* Pass correct -j flag to waf. Closes: #748584

11. By Adrian Knoth on 2014-05-15

Imported Upstream version 3.5.380~dfsg

10. By Adrian Knoth on 2014-02-25

* Imported Upstream version 3.5.357~dfsg
* Critical bugfix release. All users are recommended to upgrade.
* Details: https://community.ardour.org/node/8015

9. By Adrian Knoth on 2014-01-24

[ Jaromír Mikeš ]
* Use higher resolution picture for desktop icon (Closes: #729890).

[ Adrian Knoth ]
* Change Name entry in desktop file (Closes: #729890)
* Remove python runtime dependencies
* Imported Upstream version 3.5.308~dfsg (Closes: #734079 #733969)

=== modified file '.pc/applied-patches'
--- .pc/applied-patches	2013-11-06 13:22:44 +0000
+++ .pc/applied-patches	2015-05-02 14:23:30 +0000
@@ -1,2 +1,4 @@
 waf.patch
 wscript.patch
+log-stdout.patch
+midi-data-loss.patch
 
=== added directory '.pc/log-stdout.patch'
=== added file '.pc/log-stdout.patch/wscript'
--- .pc/log-stdout.patch/wscript	1970-01-01 00:00:00 +0000
+++ .pc/log-stdout.patch/wscript	2015-05-02 14:23:30 +0000
@@ -0,0 +1,822 @@
+#!/usr/bin/env python
+from waflib.extras import autowaf as autowaf
+from waflib import Options
+import os
+import re
+import string
+import subprocess
+import sys
+
+def fetch_git_revision ():
+    cmd = "git describe HEAD"
+    output = subprocess.Popen(cmd, shell=True, stderr=subprocess.STDOUT, stdout=subprocess.PIPE).communicate()[0].splitlines()
+    rev = output[0].decode ('utf-8')
+    return rev
+
+def fetch_tarball_revision ():
+    if not os.path.exists ('libs/ardour/revision.cc'):
+        print 'This tarball was not created correctly - it is missing libs/ardour/revision.cc'
+        sys.exit (1)
+    with open('libs/ardour/revision.cc') as f:
+        content = f.readlines()
+        remove_punctuation_map = dict((ord(char), None) for char in '";')
+        return content[1].decode('utf-8').strip().split(' ')[7].translate (remove_punctuation_map)
+
+rev = fetch_tarball_revision ()
+
+#
+# rev is now of the form MAJOR.MINOR-rev-commit
+#
+
+parts = rev.split ('.')
+MAJOR = parts[0]
+MINOR = parts[1]
+MICRO = parts[2]
+
+V = MAJOR + '.' + MINOR + '.' + MICRO
+#
+# it is important that VERSION *not* be unicode string
+# because if it is, it breaks waf somehow.
+#
+VERSION = V.encode ('ascii', 'ignore')
+APPNAME = 'Ardour' + MAJOR
+
+# Mandatory variables
+top = '.'
+out = 'build'
+
+children = [
+        'libs/pbd',
+        'libs/midi++2',
+        'libs/evoral',
+        'libs/vamp-sdk',
+        'libs/qm-dsp',
+        'libs/vamp-plugins',
+        'libs/taglib',
+        'libs/libltc',
+        'libs/rubberband',
+        'libs/surfaces',
+        'libs/panners',
+        'libs/backends',
+        'libs/timecode',
+        'libs/ardour',
+        'libs/gtkmm2ext',
+        'libs/clearlooks-newer',
+        'libs/audiographer',
+        'libs/plugins/reasonablesynth.lv2',
+        'gtk2_ardour',
+        'export',
+        'midi_maps',
+        'mcp',
+        'patchfiles'
+]
+
+i18n_children = [
+        'gtk2_ardour',
+        'libs/ardour',
+        'libs/gtkmm2ext',
+]
+
+if sys.platform == 'linux2':
+    children += [ 'tools/sanity_check' ]
+    lxvst_default = True
+elif sys.platform == 'darwin':
+    children += [ 'libs/appleutility' ]
+    lxvst_default = False
+else:
+    lxvst_default = False
+
+# Version stuff
+
+def fetch_gcc_version (CC):
+    cmd = "LANG= %s --version" % CC
+    output = subprocess.Popen(cmd, shell=True, stderr=subprocess.STDOUT, stdout=subprocess.PIPE).communicate()[0].splitlines()
+    o = output[0].decode('utf-8')
+    version = o.split(' ')[2].split('.')
+    return version
+
+def create_stored_revision():
+    rev = ""
+    if os.path.exists('.git'):
+        rev = fetch_git_revision();
+        print("Git version: " + rev + "\n")
+    elif os.path.exists('libs/ardour/revision.cc'):
+        print("Using packaged revision")
+        return
+    else:
+        print("Missing libs/ardour/revision.cc.  Blame the packager.")
+        sys.exit(-1)
+
+    try:
+        #
+        # if you change the format of this, be sure to fix fetch_tarball_revision() above
+        # so that  it still works.
+        #
+        text =  '#include "ardour/revision.h"\n'
+        text += 'namespace ARDOUR { const char* revision = \"%s\"; }\n' % rev
+        print('Writing revision info to libs/ardour/revision.cc using ' + rev)
+        o = open('libs/ardour/revision.cc', 'w')
+        o.write(text)
+        o.close()
+    except IOError:
+        print('Could not open libs/ardour/revision.cc for writing\n')
+        sys.exit(-1)
+
+def set_compiler_flags (conf,opt):
+    #
+    # Compiler flags and other system-dependent stuff
+    #
+
+    build_host_supports_sse = False
+
+    # Flags necessary for building
+    compiler_flags = []     # generic
+    c_flags = []            # C-specific
+    cxx_flags = []          # C++-specific
+    linker_flags = []
+
+    # Optimization flags (overridable)
+    optimization_flags = []
+
+    # Debugging flags
+    debug_flags = []
+
+    u = os.uname ()
+    cpu = u[4]
+    platform = u[0].lower()
+    version = u[2]
+
+    # waf adds -O0 -g itself. thanks waf!
+    is_clang = conf.env['CXX'][0].endswith('clang++')
+    
+    if conf.options.cxx11:
+        conf.check_cxx(cxxflags=["-std=c++11"])
+        cxx_flags.append('-std=c++11')
+        if platform == "darwin":
+            cxx_flags.append('-stdlib=libc++')
+            link_flags.append('-lc++')
+            # Prevents visibility issues in standard headers
+            conf.define("_DARWIN_C_SOURCE", 1)
+
+    if conf.options.asan:
+        conf.check_cxx(cxxflags=["-fsanitize=address", "-fno-omit-frame-pointer"], linkflags=["-fsanitize=address"])
+        cxx_flags.append('-fsanitize=address')
+        cxx_flags.append('-fno-omit-frame-pointer')
+        linker_flags.append('-fsanitize=address')
+
+    if is_clang and platform == "darwin":
+        # Silence warnings about the non-existing osx clang compiler flags
+        # -compatibility_version and -current_version.  These are Waf
+        # generated and not needed with clang
+        cxx_flags.append("-Qunused-arguments")
+        
+    if opt.gprofile:
+        debug_flags = [ '-pg' ]
+
+    # Autodetect
+    if opt.dist_target == 'auto':
+        if platform == 'darwin':
+            # The [.] matches to the dot after the major version, "." would match any character
+            if re.search ("^[0-7][.]", version) != None:
+                conf.env['build_target'] = 'panther'
+            elif re.search ("^8[.]", version) != None:
+                conf.env['build_target'] = 'tiger'
+            elif re.search ("^9[.]", version) != None:
+                conf.env['build_target'] = 'leopard'
+            elif re.search ("^10[.]", version) != None:
+                conf.env['build_target'] = 'snowleopard'
+            elif re.search ("^11[.]", version) != None:
+                conf.env['build_target'] = 'lion'
+            else:
+                conf.env['build_target'] = 'mountainlion'
+        else:
+            match = re.search(
+                    "(?P<cpu>i[0-6]86|x86_64|powerpc|ppc|ppc64|arm|s390x?)",
+                    cpu)
+            if (match):
+                conf.env['build_target'] = match.group("cpu")
+                if re.search("i[0-5]86", conf.env['build_target']):
+                    conf.env['build_target'] = "i386"
+            else:
+                conf.env['build_target'] = 'none'
+    else:
+        conf.env['build_target'] = opt.dist_target
+
+    if conf.env['build_target'] == 'snowleopard':
+        #
+        # stupid OS X 10.6 has a bug in math.h that prevents llrint and friends
+        # from being visible.
+        # 
+        compiler_flags.append ('-U__STRICT_ANSI__')
+
+    if cpu == 'powerpc' and conf.env['build_target'] != 'none':
+        #
+        # Apple/PowerPC optimization options
+        #
+        # -mcpu=7450 does not reliably work with gcc 3.*
+        #
+        if opt.dist_target == 'panther' or opt.dist_target == 'tiger':
+            if platform == 'darwin':
+                # optimization_flags.extend ([ "-mcpu=7450", "-faltivec"])
+                # to support g3s but still have some optimization for above
+                compiler_flags.extend ([ "-mcpu=G3", "-mtune=7450"])
+            else:
+                compiler_flags.extend ([ "-mcpu=7400", "-maltivec", "-mabi=altivec"])
+        else:
+            compiler_flags.extend([ "-mcpu=750", "-mmultiple" ])
+        compiler_flags.extend (["-mhard-float", "-mpowerpc-gfxopt"])
+        optimization_flags.extend (["-Os"])
+
+    elif ((re.search ("i[0-9]86", cpu) != None) or (re.search ("x86_64", cpu) != None)) and conf.env['build_target'] != 'none':
+
+
+        #
+        # ARCH_X86 means anything in the x86 family from i386 to x86_64
+        # the compile-time presence of the macro _LP64 is used to 
+        # distingush 32 and 64 bit assembler
+        #
+
+        if (re.search ("(i[0-9]86|x86_64)", cpu) != None):
+            compiler_flags.append ("-DARCH_X86")
+
+        if platform == 'linux' :
+
+            #
+            # determine processor flags via /proc/cpuinfo
+            #
+
+            if conf.env['build_target'] != 'i386':
+
+                flag_line = os.popen ("cat /proc/cpuinfo | grep '^flags'").read()[:-1]
+                x86_flags = flag_line.split (": ")[1:][0].split ()
+
+                if "mmx" in x86_flags:
+                    compiler_flags.append ("-mmmx")
+                if "sse" in x86_flags:
+                    build_host_supports_sse = True
+                if "3dnow" in x86_flags:
+                    compiler_flags.append ("-m3dnow")
+
+            if cpu == "i586":
+                compiler_flags.append ("-march=i586")
+            elif cpu == "i686":
+                compiler_flags.append ("-march=i686")
+
+        if not is_clang and ((conf.env['build_target'] == 'i686') or (conf.env['build_target'] == 'x86_64')) and build_host_supports_sse:
+            compiler_flags.extend (["-msse", "-mfpmath=sse", "-DUSE_XMMINTRIN"])
+
+    # end of processor-specific section
+
+    # optimization section
+    if conf.env['FPU_OPTIMIZATION']:
+        if sys.platform == 'darwin':
+            compiler_flags.append("-DBUILD_VECLIB_OPTIMIZATIONS");
+            linker_flags.append("-framework Accelerate")
+        elif conf.env['build_target'] == 'i686' or conf.env['build_target'] == 'x86_64':
+            compiler_flags.append ("-DBUILD_SSE_OPTIMIZATIONS")
+        if not build_host_supports_sse:
+            print("\nWarning: you are building Ardour with SSE support even though your system does not support these instructions. (This may not be an error, especially if you are a package maintainer)")
+
+    # end optimization section
+
+    #
+    # no VST on x86_64
+    #
+
+    if conf.env['build_target'] == 'x86_64' and opt.windows_vst:
+        print("\n\n==================================================")
+        print("You cannot use VST plugins with a 64 bit host. Please run waf with --windows-vst=0")
+        print("\nIt is theoretically possible to build a 32 bit host on a 64 bit system.")
+        print("However, this is tricky and not recommended for beginners.")
+        sys.exit (-1)
+
+    if opt.lxvst:
+        if conf.env['build_target'] == 'x86_64':
+            compiler_flags.append("-DLXVST_64BIT")
+        else:
+            compiler_flags.append("-DLXVST_32BIT")
+
+    #
+    # a single way to test if we're on OS X
+    #
+
+    if conf.env['build_target'] in ['panther', 'tiger', 'leopard', 'snowleopard' ]:
+        conf.define ('IS_OSX', 1)
+        # force tiger or later, to avoid issues on PPC which defaults
+        # back to 10.1 if we don't tell it otherwise.
+
+        compiler_flags.extend(
+                ("-DMAC_OS_X_VERSION_MIN_REQUIRED=1040",
+                 '-mmacosx-version-min=10.4'))
+
+    elif conf.env['build_target'] in [ 'lion', 'mountainlion' ]:
+        compiler_flags.extend(
+                ("-DMAC_OS_X_VERSION_MIN_REQUIRED=1070",
+                 '-mmacosx-version-min=10.7'))
+    else:
+        conf.define ('IS_OSX', 0)
+
+    #
+    # save off CPU element in an env
+    #
+    conf.define ('CONFIG_ARCH', cpu)
+
+    #
+    # ARCH="..." overrides all
+    #
+
+    if opt.arch != None:
+        optimization_flags = opt.arch.split()
+
+    #
+    # prepend boiler plate optimization flags that work on all architectures
+    #
+
+    optimization_flags[:0] = ["-pipe"]
+
+    # don't prepend optimization flags if "-O<something>" is present
+    prepend_opt_flags = True
+    for flag in optimization_flags:
+        if flag.startswith("-O"):
+            prepend_opt_flags = False
+            break
+
+    if prepend_opt_flags:
+        optimization_flags[:0] = [
+                "-O3",
+                "-fomit-frame-pointer",
+                "-ffast-math",
+                "-fstrength-reduce"
+                ]
+
+    if opt.stl_debug:
+        cxx_flags.append("-D_GLIBCXX_DEBUG")
+
+    if conf.env['DEBUG_RT_ALLOC']:
+        compiler_flags.append('-DDEBUG_RT_ALLOC')
+        linker_flags.append('-ldl')
+
+    if conf.env['DEBUG_DENORMAL_EXCEPTION']:
+        compiler_flags.append('-DDEBUG_DENORMAL_EXCEPTION')
+
+    if opt.universal:
+        if opt.generic:
+            print ('Specifying Universal and Generic builds at the same time is not supported')
+            sys.exit (1)
+        else:
+            if not Options.options.nocarbon:
+                compiler_flags.extend(("-arch", "i386", "-arch", "ppc"))
+                linker_flags.extend(("-arch", "i386", "-arch", "ppc"))
+            else:
+                compiler_flags.extend(
+                        ("-arch", "x86_64", "-arch", "i386", "-arch", "ppc"))
+                linker_flags.extend(
+                        ("-arch", "x86_64", "-arch", "i386", "-arch", "ppc"))
+    else:
+        if opt.generic:
+            compiler_flags.extend(('-arch', 'i386'))
+            linker_flags.extend(('-arch', 'i386'))
+
+    #
+    # warnings flags
+    #
+
+    compiler_flags.extend(
+            ('-Wall', '-Wpointer-arith', '-Wcast-qual', '-Wcast-align'))
+
+    c_flags.extend(('-Wstrict-prototypes', '-Wmissing-prototypes'))
+    cxx_flags.append('-Woverloaded-virtual')
+
+    #
+    # more boilerplate
+    #
+
+    # need ISOC9X for llabs()
+    compiler_flags.extend(
+            ('-DBOOST_SYSTEM_NO_DEPRECATED', '-D_ISOC9X_SOURCE',
+             '-D_LARGEFILE64_SOURCE', '-D_FILE_OFFSET_BITS=64'))
+    cxx_flags.extend(('-D__STDC_LIMIT_MACROS', '-D__STDC_FORMAT_MACROS'))
+
+    if opt.nls:
+        compiler_flags.append('-DENABLE_NLS')
+
+    if opt.debug:
+        conf.env.append_value('CFLAGS', debug_flags)
+        conf.env.append_value('CXXFLAGS', debug_flags)
+    else:
+        conf.env.append_value('CFLAGS', optimization_flags)
+        conf.env.append_value('CXXFLAGS', optimization_flags)
+
+    if opt.backtrace:
+        if platform != 'darwin' and not is_clang:
+            linker_flags += [ '-rdynamic' ]
+
+    conf.env.append_value('CFLAGS', compiler_flags)
+    conf.env.append_value('CFLAGS', c_flags)
+    conf.env.append_value('CXXFLAGS', compiler_flags)
+    conf.env.append_value('CXXFLAGS', cxx_flags)
+    conf.env.append_value('LINKFLAGS', linker_flags)
+
+#----------------------------------------------------------------
+
+# Waf stages
+
+def options(opt):
+    opt.load('compiler_c')
+    opt.load('compiler_cxx')
+    autowaf.set_options(opt, debug_by_default=True)
+    opt.add_option('--program-name', type='string', action='store', default='Ardour', dest='program_name',
+                    help='The user-visible name of the program being built')
+    opt.add_option('--arch', type='string', action='store', dest='arch',
+                    help='Architecture-specific compiler flags')
+    opt.add_option('--backtrace', action='store_true', default=True, dest='backtrace',
+                    help='Compile with -rdynamic -- allow obtaining backtraces from within Ardour')
+    opt.add_option('--no-carbon', action='store_true', default=False, dest='nocarbon',
+                    help='Compile without support for AU Plugins with only CARBON UI (needed for 64bit)')
+    opt.add_option('--boost-sp-debug', action='store_true', default=False, dest='boost_sp_debug',
+                    help='Compile with Boost shared pointer debugging')
+    opt.add_option('--depstack-root', type='string', default='~', dest='depstack_root',
+                    help='Directory/folder where dependency stack trees (gtk, a3) can be found (defaults to ~)')
+    opt.add_option('--dist-target', type='string', default='auto', dest='dist_target',
+                    help='Specify the target for cross-compiling [auto,none,x86,i386,i686,x86_64,powerpc,tiger,leopard]')
+    opt.add_option('--fpu-optimization', action='store_true', default=True, dest='fpu_optimization',
+                    help='Build runtime checked assembler code (default)')
+    opt.add_option('--no-fpu-optimization', action='store_false', dest='fpu_optimization')
+    opt.add_option('--freedesktop', action='store_true', default=False, dest='freedesktop',
+                    help='Install MIME type, icons and .desktop file as per freedesktop.org standards')
+    opt.add_option('--freebie', action='store_true', default=False, dest='freebie',
+                    help='Build a version suitable for distribution as a zero-cost binary')
+    opt.add_option('--gprofile', action='store_true', default=False, dest='gprofile',
+                    help='Compile for use with gprofile')
+    opt.add_option('--internal-shared-libs', action='store_true', default=True, dest='internal_shared_libs',
+                   help='Build internal libs as shared libraries')
+    opt.add_option('--internal-static-libs', action='store_false', dest='internal_shared_libs',
+                   help='Build internal libs as static libraries')
+    opt.add_option('--use-external-libs', action='store_true', default=False, dest='use_external_libs',
+                   help='Use external/system versions of some bundled libraries')
+    opt.add_option('--lv2', action='store_true', default=True, dest='lv2',
+                    help='Compile with support for LV2 (if Lilv+Suil is available)')
+    opt.add_option('--no-lv2', action='store_false', dest='lv2',
+                    help='Do not compile with support for LV2')
+    opt.add_option('--lxvst', action='store_true', default=lxvst_default, dest='lxvst',
+                    help='Compile with support for linuxVST plugins')
+    opt.add_option('--nls', action='store_true', default=True, dest='nls',
+                    help='Enable i18n (native language support) (default)')
+    opt.add_option('--no-nls', action='store_false', dest='nls')
+    opt.add_option('--phone-home', action='store_true', default=True, dest='phone_home',
+                   help='Contact ardour.org at startup for new announcements')
+    opt.add_option('--no-phone-home', action='store_false', dest='phone_home',
+                   help='Do not contact ardour.org at startup for new announcements')
+    opt.add_option('--stl-debug', action='store_true', default=False, dest='stl_debug',
+                    help='Build with debugging for the STL')
+    opt.add_option('--rt-alloc-debug', action='store_true', default=False, dest='rt_alloc_debug',
+                    help='Build with debugging for memory allocation in the real-time thread')
+    opt.add_option('--pt-timing', action='store_true', default=False, dest='pt_timing',
+                    help='Build with logging of timing in the process thread(s)')
+    opt.add_option('--denormal-exception', action='store_true', default=False, dest='denormal_exception',
+                    help='Raise a floating point exception if a denormal is detected')
+    opt.add_option('--test', action='store_true', default=False, dest='build_tests',
+                    help="Build unit tests")
+    opt.add_option('--run-tests', action='store_true', default=False, dest='run_tests',
+                    help="Run tests after build")
+    opt.add_option('--single-tests', action='store_true', default=False, dest='single_tests',
+                    help="Build a single executable for each unit test")
+    #opt.add_option('--tranzport', action='store_true', default=False, dest='tranzport',
+    # help='Compile with support for Frontier Designs Tranzport (if libusb is available)')
+    opt.add_option('--universal', action='store_true', default=False, dest='universal',
+                    help='Compile as universal binary (OS X ONLY, requires that external libraries are universal)')
+    opt.add_option('--generic', action='store_true', default=False, dest='generic',
+                    help='Compile with -arch i386 (OS X ONLY)')
+    opt.add_option('--versioned', action='store_true', default=False, dest='versioned',
+                    help='Add revision information to executable name inside the build directory')
+    opt.add_option('--windows-vst', action='store_true', default=False, dest='windows_vst',
+                    help='Compile with support for Windows VST')
+    opt.add_option('--windows-key', type='string', action='store', dest='windows_key', default='Mod4><Super',
+                    help='X Modifier(s) (Mod1,Mod2, etc) for the Windows key (X11 builds only). ' +
+                    'Multiple modifiers must be separated by \'><\'')
+    opt.add_option('--boost-include', type='string', action='store', dest='boost_include', default='',
+                    help='directory where Boost header files can be found')
+    opt.add_option('--also-include', type='string', action='store', dest='also_include', default='',
+                    help='additional include directory where header files can be found (split multiples with commas)')
+    opt.add_option('--also-libdir', type='string', action='store', dest='also_libdir', default='',
+                    help='additional include directory where shared libraries can be found (split multiples with commas)')
+    opt.add_option('--wine-include', type='string', action='store', dest='wine_include', default='/usr/include/wine/windows',
+                    help='directory where Wine\'s Windows header files can be found')
+    opt.add_option('--noconfirm', action='store_true', default=False, dest='noconfirm',
+                    help='Do not ask questions that require confirmation during the build')
+    opt.add_option('--cxx11', action='store_true', default=False, dest='cxx11',
+                    help='Turn on c++11 compiler flags (-std=c++11)')
+    opt.add_option('--address-sanitizer', action='store_true', default=False, dest='asan',
+                    help='Turn on AddressSanitizer (requires GCC >= 4.8 or clang >= 3.1)')
+    for i in children:
+        opt.recurse(i)
+
+def sub_config_and_use(conf, name, has_objects = True):
+    conf.recurse(name)
+    autowaf.set_local_lib(conf, name, has_objects)
+
+def configure(conf):
+    conf.load('compiler_c')
+    conf.load('compiler_cxx')
+    conf.env['VERSION'] = VERSION
+    conf.env['MAJOR'] = MAJOR
+    conf.env['MINOR'] = MINOR
+    conf.line_just = 52
+    autowaf.set_recursive()
+    autowaf.configure(conf)
+    autowaf.display_header('Ardour Configuration')
+
+    gcc_versions = fetch_gcc_version(str(conf.env['CC']))
+    if not Options.options.debug and gcc_versions[0] == '4' and gcc_versions[1] > '4':
+        print('Version 4.5 of gcc is not ready for use when compiling Ardour with optimization.')
+        print('Please use a different version or re-configure with --debug')
+        exit (1)
+
+    # systems with glibc have libintl builtin. systems without require explicit
+    # linkage against libintl.
+    #
+
+    pkg_config_path = os.getenv('PKG_CONFIG_PATH')
+    user_gtk_root = os.path.expanduser (Options.options.depstack_root + '/gtk/inst')
+
+    if pkg_config_path is not None and pkg_config_path.find (user_gtk_root) >= 0:
+        # told to search user_gtk_root
+        prefinclude = ''.join ([ '-I', user_gtk_root + '/include'])
+        preflib = ''.join ([ '-L', user_gtk_root + '/lib'])
+        conf.env.append_value('CFLAGS', [ prefinclude ])
+        conf.env.append_value('CXXFLAGS',  [prefinclude ])
+        conf.env.append_value('LINKFLAGS', [ preflib ])
+        autowaf.display_msg(conf, 'Will build against private GTK dependency stack in ' + user_gtk_root, 'yes')
+    else:
+        autowaf.display_msg(conf, 'Will build against private GTK dependency stack', 'no')
+
+    if sys.platform == 'darwin':
+        conf.define ('NEED_INTL', 1)
+        autowaf.display_msg(conf, 'Will use explicit linkage against libintl in ' + user_gtk_root, 'yes')
+    else:
+        # libintl is part of the system, so use it
+        autowaf.display_msg(conf, 'Will rely on libintl built into libc', 'yes')
+            
+    user_ardour_root = os.path.expanduser (Options.options.depstack_root + '/a3/inst')
+    if pkg_config_path is not None and pkg_config_path.find (user_ardour_root) >= 0:
+        # told to search user_ardour_root
+        prefinclude = ''.join ([ '-I', user_ardour_root + '/include'])
+        preflib = ''.join ([ '-L', user_ardour_root + '/lib'])
+        conf.env.append_value('CFLAGS', [ prefinclude ])
+        conf.env.append_value('CXXFLAGS',  [prefinclude ])
+        conf.env.append_value('LINKFLAGS', [ preflib ])
+        autowaf.display_msg(conf, 'Will build against private Ardour dependency stack in ' + user_ardour_root, 'yes')
+    else:
+        autowaf.display_msg(conf, 'Will build against private Ardour dependency stack', 'no')
+        
+    if Options.options.freebie:
+        conf.env.append_value ('CFLAGS', '-DNO_PLUGIN_STATE')
+        conf.env.append_value ('CXXFLAGS', '-DNO_PLUGIN_STATE')
+        conf.define ('NO_PLUGIN_STATE', 1)
+
+    if sys.platform == 'darwin':
+
+        # this is required, potentially, for anything we link and then relocate into a bundle
+        conf.env.append_value('LINKFLAGS', [ '-Xlinker', '-headerpad_max_install_names' ])
+
+        conf.define ('HAVE_COREAUDIO', 1)
+        conf.define ('AUDIOUNIT_SUPPORT', 1)
+
+        conf.define ('GTKOSX', 1)
+        conf.define ('TOP_MENUBAR',1)
+        conf.define ('GTKOSX',1)
+
+        # It would be nice to be able to use this to force back-compatibility with 10.4
+        # but even by the time of 11, the 10.4 SDK is no longer available in any normal
+        # way.
+        #
+        #conf.env.append_value('CXXFLAGS_OSX', "-isysroot /Developer/SDKs/MacOSX10.4u.sdk")
+        #conf.env.append_value('CFLAGS_OSX', "-isysroot /Developer/SDKs/MacOSX10.4u.sdk")
+        #conf.env.append_value('LINKFLAGS_OSX', "-sysroot /Developer/SDKs/MacOSX10.4u.sdk")
+        #conf.env.append_value('LINKFLAGS_OSX', "-sysroot /Developer/SDKs/MacOSX10.4u.sdk")
+
+        conf.env.append_value('CXXFLAGS_OSX', "-msse")
+        conf.env.append_value('CFLAGS_OSX', "-msse")
+        conf.env.append_value('CXXFLAGS_OSX', "-msse2")
+        conf.env.append_value('CFLAGS_OSX', "-msse2")
+        #
+        #       TODO: The previous sse flags NEED to be based
+        #       off processor type.  Need to add in a check
+        #       for that.
+        #
+        conf.env.append_value('CXXFLAGS_OSX', '-F/System/Library/Frameworks')
+        conf.env.append_value('CXXFLAGS_OSX', '-F/Library/Frameworks')
+
+        conf.env.append_value('LINKFLAGS_OSX', ['-framework', 'AppKit'])
+        conf.env.append_value('LINKFLAGS_OSX', ['-framework', 'CoreAudio'])
+        conf.env.append_value('LINKFLAGS_OSX', ['-framework', 'CoreAudioKit'])
+        conf.env.append_value('LINKFLAGS_OSX', ['-framework', 'CoreFoundation'])
+        conf.env.append_value('LINKFLAGS_OSX', ['-framework', 'CoreServices'])
+
+        conf.env.append_value('LINKFLAGS_OSX', ['-undefined', 'dynamic_lookup' ])
+        conf.env.append_value('LINKFLAGS_OSX', ['-flat_namespace'])
+
+        conf.env.append_value('CXXFLAGS_AUDIOUNITS', "-DAUDIOUNIT_SUPPORT")
+        conf.env.append_value('LINKFLAGS_AUDIOUNITS', ['-framework', 'AudioToolbox', '-framework', 'AudioUnit'])
+        conf.env.append_value('LINKFLAGS_AUDIOUNITS', ['-framework', 'Cocoa'])
+
+        if re.search ("^[1-9][0-9]\.", os.uname()[2]) == None and not Options.options.nocarbon:
+            conf.env.append_value('CXXFLAGS_AUDIOUNITS', "-DWITH_CARBON")
+            conf.env.append_value('LINKFLAGS_AUDIOUNITS', ['-framework', 'Carbon'])
+        else:
+            print ('No Carbon support available for this build\n')
+
+
+    if Options.options.internal_shared_libs: 
+        conf.define('INTERNAL_SHARED_LIBS', 1)
+
+    if Options.options.use_external_libs:
+        conf.define('USE_EXTERNAL_LIBS', 1)
+
+    if Options.options.boost_include != '':
+        conf.env.append_value('CXXFLAGS', '-I' + Options.options.boost_include)
+
+    if Options.options.also_include != '':
+        conf.env.append_value('CXXFLAGS', '-I' + Options.options.also_include)
+        conf.env.append_value('CFLAGS', '-I' + Options.options.also_include)
+
+    if Options.options.also_libdir != '':
+        conf.env.append_value('LDFLAGS', '-L' + Options.options.also_libdir)
+
+    if Options.options.boost_sp_debug:
+        conf.env.append_value('CXXFLAGS', '-DBOOST_SP_ENABLE_DEBUG_HOOKS')
+
+    conf.check_cxx(fragment = "#include <boost/version.hpp>\nint main(void) { return (BOOST_VERSION >= 103900 ? 0 : 1); }\n",
+                  execute = "1",
+                  mandatory = True,
+                  msg = 'Checking for boost library >= 1.39',
+                  okmsg = 'ok',
+                  errmsg = 'too old\nPlease install boost version 1.39 or higher.')
+
+    autowaf.check_pkg(conf, 'glib-2.0', uselib_store='GLIB', atleast_version='2.2')
+    autowaf.check_pkg(conf, 'gthread-2.0', uselib_store='GTHREAD', atleast_version='2.2')
+    autowaf.check_pkg(conf, 'glibmm-2.4', uselib_store='GLIBMM', atleast_version='2.32.0')
+    autowaf.check_pkg(conf, 'sndfile', uselib_store='SNDFILE', atleast_version='1.0.18')
+    autowaf.check_pkg(conf, 'giomm-2.4', uselib_store='GIOMM', atleast_version='2.2')
+    autowaf.check_pkg(conf, 'libcurl', uselib_store='CURL', atleast_version='7.0.0')
+    autowaf.check_pkg(conf, 'liblo', uselib_store='LO', atleast_version='0.26')
+
+    conf.check_cc(function_name='dlopen', header_name='dlfcn.h', lib='dl', uselib_store='DL')
+
+    # Tell everyone that this is a waf build
+
+    conf.env.append_value('CFLAGS', '-DWAF_BUILD')
+    conf.env.append_value('CXXFLAGS', '-DWAF_BUILD')
+
+    # Set up waf environment and C defines
+    opts = Options.options
+    if opts.phone_home:
+        conf.define('PHONE_HOME', 1)
+        conf.env['PHONE_HOME'] = True
+    if opts.fpu_optimization:
+        conf.env['FPU_OPTIMIZATION'] = True
+    if opts.nls:
+        conf.define('ENABLE_NLS', 1)
+        conf.env['ENABLE_NLS'] = True
+    if opts.build_tests:
+        conf.env['BUILD_TESTS'] = True
+        conf.env['RUN_TESTS'] = opts.run_tests
+    if opts.single_tests:
+        conf.env['SINGLE_TESTS'] = opts.single_tests
+    #if opts.tranzport:
+    #    conf.env['TRANZPORT'] = 1
+    if opts.windows_vst:
+        conf.define('WINDOWS_VST_SUPPORT', 1)
+        conf.env['WINDOWS_VST_SUPPORT'] = True
+        conf.env.append_value('CFLAGS', '-I' + Options.options.wine_include)
+        conf.env.append_value('CXXFLAGS', '-I' + Options.options.wine_include)
+        autowaf.check_header(conf, 'cxx', 'windows.h', mandatory = True)
+    if opts.lxvst:
+        conf.define('LXVST_SUPPORT', 1)
+        conf.env['LXVST_SUPPORT'] = True
+    conf.define('WINDOWS_KEY', opts.windows_key)
+    conf.env['PROGRAM_NAME'] = opts.program_name
+    if opts.rt_alloc_debug:
+        conf.define('DEBUG_RT_ALLOC', 1)
+        conf.env['DEBUG_RT_ALLOC'] = True
+    if opts.pt_timing:
+        conf.define('PT_TIMING', 1)
+        conf.env['PT_TIMING'] = True
+    if opts.denormal_exception:
+        conf.define('DEBUG_DENORMAL_EXCEPTION', 1)
+        conf.env['DEBUG_DENORMAL_EXCEPTION'] = True
+    if opts.build_tests:
+        autowaf.check_pkg(conf, 'cppunit', uselib_store='CPPUNIT', atleast_version='1.12.0', mandatory=True)
+
+    set_compiler_flags (conf, Options.options)
+
+    for i in children:
+        sub_config_and_use(conf, i)
+
+    # Fix utterly braindead FLAC include path to not smash assert.h
+    conf.env['INCLUDES_FLAC'] = []
+
+    config_text = open('libs/ardour/config_text.cc', "w")
+    config_text.write('''#include "ardour/ardour.h"
+namespace ARDOUR {
+const char* const ardour_config_info = "\\n\\
+''')
+
+    def write_config_text(title, val):
+        autowaf.display_msg(conf, title, val)
+        config_text.write(title + ': ')
+        config_text.write(str(val))
+        config_text.write("\\n\\\n")
+
+    write_config_text('Build documentation',   conf.env['DOCS'])
+    write_config_text('Debuggable build',      conf.env['DEBUG'])
+    write_config_text('Export all symbols (backtrace)', opts.backtrace)
+    write_config_text('Install prefix',        conf.env['PREFIX'])
+    write_config_text('Strict compiler flags', conf.env['STRICT'])
+    write_config_text('Internal Shared Libraries', conf.is_defined('INTERNAL_SHARED_LIBS'))
+    write_config_text('Use External Libraries', conf.is_defined('USE_EXTERNAL_LIBS'))
+
+    write_config_text('Architecture flags',    opts.arch)
+    write_config_text('Aubio',                 conf.is_defined('HAVE_AUBIO'))
+    write_config_text('AudioUnits',            conf.is_defined('AUDIOUNIT_SUPPORT'))
+    write_config_text('No plugin state',       conf.is_defined('NO_PLUGIN_STATE'))
+    write_config_text('Build target',          conf.env['build_target'])
+    write_config_text('CoreAudio',             conf.is_defined('HAVE_COREAUDIO'))
+    write_config_text('Debug RT allocations',  conf.is_defined('DEBUG_RT_ALLOC'))
+    write_config_text('Process thread timing', conf.is_defined('PT_TIMING'))
+    write_config_text('Denormal exceptions',   conf.is_defined('DEBUG_DENORMAL_EXCEPTION'))
+    write_config_text('FLAC',                  conf.is_defined('HAVE_FLAC'))
+    write_config_text('FPU optimization',      opts.fpu_optimization)
+    write_config_text('Freedesktop files',     opts.freedesktop)
+    write_config_text('LV2 UI embedding',      conf.is_defined('HAVE_SUIL'))
+    write_config_text('LV2 support',           conf.is_defined('LV2_SUPPORT'))
+    write_config_text('LXVST support',         conf.is_defined('LXVST_SUPPORT'))
+    write_config_text('OGG',                   conf.is_defined('HAVE_OGG'))
+    write_config_text('Phone home',            conf.is_defined('PHONE_HOME'))
+    write_config_text('Program name',          opts.program_name)
+    write_config_text('Rubberband',            conf.is_defined('HAVE_RUBBERBAND'))
+    write_config_text('Samplerate',            conf.is_defined('HAVE_SAMPLERATE'))
+#    write_config_text('Soundtouch',            conf.is_defined('HAVE_SOUNDTOUCH'))
+    write_config_text('Translation',           opts.nls)
+#    write_config_text('Tranzport',             opts.tranzport)
+    write_config_text('Unit tests',            conf.env['BUILD_TESTS'])
+    write_config_text('Universal binary',      opts.universal)
+    write_config_text('Generic x86 CPU',       opts.generic)
+    write_config_text('Windows VST support',   opts.windows_vst)
+    write_config_text('Wiimote support',       conf.is_defined('BUILD_WIIMOTE'))
+    write_config_text('Windows key',           opts.windows_key)
+
+    write_config_text('C compiler flags',      conf.env['CFLAGS'])
+    write_config_text('C++ compiler flags',    conf.env['CXXFLAGS'])
+    write_config_text('Linker flags',           conf.env['LINKFLAGS'])
+
+    config_text.write ('";\n}\n')
+    config_text.close ()
+    print('')
+
+def build(bld):
+    create_stored_revision()
+
+    # add directories that contain only headers, to workaround an issue with waf
+
+    bld.path.find_dir ('libs/evoral/evoral')
+    if not bld.is_defined('USE_EXTERNAL_LIBS'):
+        bld.path.find_dir ('libs/vamp-sdk/vamp-sdk')
+    bld.path.find_dir ('libs/surfaces/control_protocol/control_protocol')
+    bld.path.find_dir ('libs/timecode/timecode')
+    if not bld.is_defined('USE_EXTERNAL_LIBS'):
+        bld.path.find_dir ('libs/libltc/ltc')
+        bld.path.find_dir ('libs/rubberband/rubberband')
+    bld.path.find_dir ('libs/gtkmm2ext/gtkmm2ext')
+    bld.path.find_dir ('libs/ardour/ardour')
+    if not bld.is_defined('USE_EXTERNAL_LIBS'):
+        bld.path.find_dir ('libs/taglib/taglib')
+    bld.path.find_dir ('libs/pbd/pbd')
+
+    autowaf.set_recursive()
+
+    for i in children:
+        bld.recurse(i)
+
+    bld.install_files (os.path.join(bld.env['SYSCONFDIR'], 'ardour3', ), 'ardour_system.rc')
+
+    if bld.env['RUN_TESTS']:
+        bld.add_post_fun(test)
+
+def i18n(bld):
+    bld.recurse (i18n_children)
+
+def i18n_pot(bld):
+    bld.recurse (i18n_children)
+
+def i18n_po(bld):
+    bld.recurse (i18n_children)
+
+def i18n_mo(bld):
+    bld.recurse (i18n_children)
+
+def tarball(bld):
+    create_stored_revision()
+
+def test(bld):
+    subprocess.call("gtk2_ardour/artest")
 
=== added directory '.pc/midi-data-loss.patch'
=== added directory '.pc/midi-data-loss.patch/libs'
=== added directory '.pc/midi-data-loss.patch/libs/ardour'
=== added file '.pc/midi-data-loss.patch/libs/ardour/smf_source.cc'
--- .pc/midi-data-loss.patch/libs/ardour/smf_source.cc	1970-01-01 00:00:00 +0000
+++ .pc/midi-data-loss.patch/libs/ardour/smf_source.cc	2015-05-02 14:23:30 +0000
@@ -0,0 +1,764 @@
+/*
+    Copyright (C) 2006 Paul Davis
+    Author: David Robillard
+
+    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 <vector>
+
+#include <sys/time.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <errno.h>
+#include <regex.h>
+
+#include "pbd/pathscanner.h"
+#include "pbd/stl_delete.h"
+#include "pbd/strsplit.h"
+
+#include <glibmm/miscutils.h>
+#include <glibmm/fileutils.h>
+
+#include "evoral/Control.hpp"
+#include "evoral/evoral/SMF.hpp"
+
+#include "ardour/event_type_map.h"
+#include "ardour/midi_model.h"
+#include "ardour/midi_ring_buffer.h"
+#include "ardour/midi_state_tracker.h"
+#include "ardour/session.h"
+#include "ardour/smf_source.h"
+#include "ardour/debug.h"
+
+#include "i18n.h"
+
+using namespace ARDOUR;
+using namespace Glib;
+using namespace PBD;
+using namespace Evoral;
+
+/** Constructor used for new internal-to-session files.  File cannot exist. */
+SMFSource::SMFSource (Session& s, const string& path, Source::Flag flags)
+	: Source(s, DataType::MIDI, path, flags)
+	, MidiSource(s, path, flags)
+	, FileSource(s, DataType::MIDI, path, string(), flags)
+	, Evoral::SMF()
+	, _last_ev_time_beats(0.0)
+	, _last_ev_time_frames(0)
+	, _smf_last_read_end (0)
+	, _smf_last_read_time (0)
+{
+	/* note that origin remains empty */
+
+	if (init (_path, false)) {
+		throw failed_constructor ();
+	}
+ 
+        assert (!Glib::file_test (_path, Glib::FILE_TEST_EXISTS));
+	existence_check ();
+
+	_flags = Source::Flag (_flags | Empty);
+
+	/* file is not opened until write */
+
+	if (flags & Writable) {
+		return;
+	}
+
+	if (open (_path)) {
+		throw failed_constructor ();
+	}
+
+	_open = true;
+}
+
+/** Constructor used for external-to-session files.  File must exist. */
+SMFSource::SMFSource (Session& s, const string& path)
+	: Source(s, DataType::MIDI, path, Source::Flag (0))
+	, MidiSource(s, path, Source::Flag (0))
+	, FileSource(s, DataType::MIDI, path, string(), Source::Flag (0))
+	, Evoral::SMF()
+	, _last_ev_time_beats(0.0)
+	, _last_ev_time_frames(0)
+	, _smf_last_read_end (0)
+	, _smf_last_read_time (0)
+{
+	/* note that origin remains empty */
+
+	if (init (_path, true)) {
+		throw failed_constructor ();
+	}
+ 
+        assert (Glib::file_test (_path, Glib::FILE_TEST_EXISTS));
+	existence_check ();
+
+	if (_flags & Writable) {
+		/* file is not opened until write */
+		return;
+	}
+
+	if (open (_path)) {
+		throw failed_constructor ();
+	}
+
+	_open = true;
+}
+
+/** Constructor used for existing internal-to-session files. */
+SMFSource::SMFSource (Session& s, const XMLNode& node, bool must_exist)
+	: Source(s, node)
+	, MidiSource(s, node)
+	, FileSource(s, node, must_exist)
+	, _last_ev_time_beats(0.0)
+	, _last_ev_time_frames(0)
+	, _smf_last_read_end (0)
+	, _smf_last_read_time (0)
+{
+	if (set_state(node, Stateful::loading_state_version)) {
+		throw failed_constructor ();
+	}
+
+	/* we expect the file to exist, but if no MIDI data was ever added
+	   it will have been removed at last session close. so, we don't
+	   require it to exist if it was marked Empty.
+	*/
+
+	try {
+
+		if (init (_path, true)) {
+			throw failed_constructor ();
+		}
+
+	} catch (MissingSource& err) {
+
+		if (_flags & Source::Empty) {
+			/* we don't care that the file was not found, because
+			   it was empty. But FileSource::init() will have
+			   failed to set our _path correctly, so we have to do
+			   this ourselves. Use the first entry in the search
+			   path for MIDI files, which is assumed to be the
+			   correct "main" location.
+			*/
+			std::vector<Glib::ustring> sdirs;
+			split (s.source_search_path (DataType::MIDI), sdirs, ':');
+			if (sdirs.empty()) {
+				fatal << _("Empty MIDI source search path!") << endmsg;
+				/*NOTREACHED*/
+			}
+			_path = Glib::build_filename (sdirs.front(), _path);
+			/* This might be important, too */
+			_file_is_new = true;
+		} else {
+			/* pass it on */
+			throw;
+		}
+	}
+
+	if (!(_flags & Source::Empty)) {
+		assert (Glib::file_test (_path, Glib::FILE_TEST_EXISTS));
+		existence_check ();
+	} else {
+		assert (_flags & Source::Writable);
+		/* file will be opened on write */
+		return;
+	}
+
+	if (open(_path)) {
+		throw failed_constructor ();
+	}
+
+	_open = true;
+}
+
+SMFSource::~SMFSource ()
+{
+	if (removable()) {
+		unlink (_path.c_str());
+	}
+}
+
+int
+SMFSource::open_for_write ()
+{
+	if (create (_path)) {
+		return -1;
+	}
+	_open = true;
+	return 0;
+}
+
+/** All stamps in audio frames */
+framecnt_t
+SMFSource::read_unlocked (Evoral::EventSink<framepos_t>& destination,
+                          framepos_t const               source_start,
+                          framepos_t                     start,
+                          framecnt_t                     duration,
+                          MidiStateTracker*              tracker) const
+{
+	int      ret  = 0;
+	uint64_t time = 0; // in SMF ticks, 1 tick per _ppqn
+
+	if (writable() && !_open) {
+		/* nothing to read since nothing has ben written */
+		return duration;
+	}
+
+	DEBUG_TRACE (DEBUG::MidiSourceIO, string_compose ("SMF read_unlocked: start %1 duration %2\n", start, duration));
+
+	// Output parameters for read_event (which will allocate scratch in buffer as needed)
+	uint32_t ev_delta_t = 0;
+	uint32_t ev_type    = 0;
+	uint32_t ev_size    = 0;
+	uint8_t* ev_buffer  = 0;
+
+	size_t scratch_size = 0; // keep track of scratch to minimize reallocs
+
+	BeatsFramesConverter converter(_session.tempo_map(), source_start);
+
+	const uint64_t start_ticks = (uint64_t)(converter.from(start) * ppqn());
+	DEBUG_TRACE (DEBUG::MidiSourceIO, string_compose ("SMF read_unlocked: start in ticks %1\n", start_ticks));
+
+	if (_smf_last_read_end == 0 || start != _smf_last_read_end) {
+		DEBUG_TRACE (DEBUG::MidiSourceIO, string_compose ("SMF read_unlocked: seek to %1\n", start));
+		Evoral::SMF::seek_to_start();
+		while (time < start_ticks) {
+			gint ignored;
+
+			ret = read_event(&ev_delta_t, &ev_size, &ev_buffer, &ignored);
+			if (ret == -1) { // EOF
+				_smf_last_read_end = start + duration;
+				return duration;
+			}
+			time += ev_delta_t; // accumulate delta time
+		}
+	} else {
+		DEBUG_TRACE (DEBUG::MidiSourceIO, string_compose ("SMF read_unlocked: set time to %1\n", _smf_last_read_time));
+		time = _smf_last_read_time;
+	}
+
+	_smf_last_read_end = start + duration;
+
+	while (true) {
+		gint ignored; /* XXX don't ignore note id's ??*/
+
+		ret = read_event(&ev_delta_t, &ev_size, &ev_buffer, &ignored);
+		if (ret == -1) { // EOF
+			break;
+		}
+
+		time += ev_delta_t; // accumulate delta time
+		_smf_last_read_time = time;
+
+		if (ret == 0) { // meta-event (skipped, just accumulate time)
+			continue;
+		}
+
+		ev_type = EventTypeMap::instance().midi_event_type(ev_buffer[0]);
+
+		DEBUG_TRACE (DEBUG::MidiSourceIO, string_compose ("SMF read_unlocked delta %1, time %2, buf[0] %3, type %4\n",
+								  ev_delta_t, time, ev_buffer[0], ev_type));
+
+		assert(time >= start_ticks);
+
+		/* Note that we add on the source start time (in session frames) here so that ev_frame_time
+		   is in session frames.
+		*/
+		const framepos_t ev_frame_time = converter.to(time / (double)ppqn()) + source_start;
+
+		if (ev_frame_time < start + duration) {
+			destination.write (ev_frame_time, ev_type, ev_size, ev_buffer);
+
+			if (tracker) {
+				if (ev_buffer[0] & MIDI_CMD_NOTE_ON) {
+					tracker->add (ev_buffer[1], ev_buffer[0] & 0xf);
+				} else if (ev_buffer[0] & MIDI_CMD_NOTE_OFF) {
+					tracker->remove (ev_buffer[1], ev_buffer[0] & 0xf);
+				}
+			}
+		} else {
+			break;
+		}
+
+		if (ev_size > scratch_size) {
+			scratch_size = ev_size;
+		}
+		ev_size = scratch_size; // ensure read_event only allocates if necessary
+	}
+
+	return duration;
+}
+
+framecnt_t
+SMFSource::write_unlocked (MidiRingBuffer<framepos_t>& source,
+                           framepos_t                  position,
+                           framecnt_t                  cnt)
+{
+	if (!_writing) {
+		mark_streaming_write_started ();
+	}
+
+	framepos_t        time;
+	Evoral::EventType type;
+	uint32_t          size;
+
+	size_t   buf_capacity = 4;
+	uint8_t* buf          = (uint8_t*)malloc(buf_capacity);
+
+	if (_model && !_model->writing()) {
+		_model->start_write();
+	}
+
+	Evoral::MIDIEvent<framepos_t> ev;
+	while (true) {
+		/* Get the event time, in frames since session start but ignoring looping. */
+		bool ret;
+		if (!(ret = source.peek ((uint8_t*)&time, sizeof (time)))) {
+			/* Ring is empty, no more events. */
+			break;
+		}
+
+		if ((cnt != max_framecnt) &&
+		    (time > position + _capture_length + cnt)) {
+			/* The diskstream doesn't want us to write everything, and this
+			   event is past the end of this block, so we're done for now. */
+			break;
+		}
+
+		/* Read the time, type, and size of the event. */
+		if (!(ret = source.read_prefix (&time, &type, &size))) {
+			error << _("Unable to read event prefix, corrupt MIDI ring") << endmsg;
+			break;
+		}
+
+		/* Enlarge body buffer if necessary now that we know the size. */
+		if (size > buf_capacity) {
+			buf_capacity = size;
+			buf = (uint8_t*)realloc(buf, size);
+		}
+
+		/* Read the event body into buffer. */
+		ret = source.read_contents(size, buf);
+		if (!ret) {
+			error << _("Event has time and size but no body, corrupt MIDI ring") << endmsg;
+			break;
+		}
+
+		/* Convert event time from absolute to source relative. */
+		if (time < position) {
+			error << _("Event time is before MIDI source position") << endmsg;
+			break;
+		}
+		time -= position;
+			
+		ev.set(buf, size, time);
+		ev.set_event_type(EventTypeMap::instance().midi_event_type(ev.buffer()[0]));
+		ev.set_id(Evoral::next_event_id());
+
+		if (!(ev.is_channel_event() || ev.is_smf_meta_event() || ev.is_sysex())) {
+			continue;
+		}
+
+		append_event_unlocked_frames(ev, position);
+	}
+
+	Evoral::SMF::flush ();
+	free (buf);
+
+	return cnt;
+}
+
+/** Append an event with a timestamp in beats (double) */
+void
+SMFSource::append_event_unlocked_beats (const Evoral::Event<double>& ev)
+{
+	if (!_writing || ev.size() == 0)  {
+		return;
+	}
+
+	/*printf("SMFSource: %s - append_event_unlocked_beats ID = %d time = %lf, size = %u, data = ",
+               name().c_str(), ev.id(), ev.time(), ev.size());
+	       for (size_t i = 0; i < ev.size(); ++i) printf("%X ", ev.buffer()[i]); printf("\n");*/
+
+	if (ev.time() < _last_ev_time_beats) {
+		warning << string_compose(_("Skipping event with unordered time %1"), ev.time())
+		        << endmsg;
+		return;
+	}
+
+	Evoral::event_id_t event_id;
+
+	if (ev.id() < 0) {
+		event_id  = Evoral::next_event_id();
+	} else {
+		event_id = ev.id();
+	}
+
+	if (_model) {
+		_model->append (ev, event_id);
+	}
+
+	_length_beats = max(_length_beats, ev.time());
+
+	const double delta_time_beats   = ev.time() - _last_ev_time_beats;
+	const uint32_t delta_time_ticks = (uint32_t)lrint(delta_time_beats * (double)ppqn());
+
+	Evoral::SMF::append_event_delta(delta_time_ticks, ev.size(), ev.buffer(), event_id);
+	_last_ev_time_beats = ev.time();
+	_flags = Source::Flag (_flags & ~Empty);
+}
+
+/** Append an event with a timestamp in frames (framepos_t) */
+void
+SMFSource::append_event_unlocked_frames (const Evoral::Event<framepos_t>& ev, framepos_t position)
+{
+	if (!_writing || ev.size() == 0)  {
+		return;
+	}
+
+	// printf("SMFSource: %s - append_event_unlocked_frames ID = %d time = %u, size = %u, data = ",
+	// name().c_str(), ev.id(), ev.time(), ev.size());
+	// for (size_t i=0; i < ev.size(); ++i) printf("%X ", ev.buffer()[i]); printf("\n");
+
+	if (ev.time() < _last_ev_time_frames) {
+		warning << string_compose(_("Skipping event with unordered time %1"), ev.time())
+		        << endmsg;
+		return;
+	}
+
+	BeatsFramesConverter converter(_session.tempo_map(), position);
+	const double ev_time_beats = converter.from(ev.time());
+	Evoral::event_id_t event_id;
+
+	if (ev.id() < 0) {
+		event_id  = Evoral::next_event_id();
+	} else {
+		event_id = ev.id();
+	}
+
+	if (_model) {
+		const Evoral::Event<double> beat_ev (ev.event_type(),
+		                                     ev_time_beats,
+		                                     ev.size(),
+		                                     const_cast<uint8_t*>(ev.buffer()));
+		_model->append (beat_ev, event_id);
+	}
+
+	_length_beats = max(_length_beats, ev_time_beats);
+
+	const Evoral::MusicalTime last_time_beats  = converter.from (_last_ev_time_frames);
+	const Evoral::MusicalTime delta_time_beats = ev_time_beats - last_time_beats;
+	const uint32_t            delta_time_ticks = (uint32_t)(lrint(delta_time_beats * (double)ppqn()));
+
+	Evoral::SMF::append_event_delta(delta_time_ticks, ev.size(), ev.buffer(), event_id);
+	_last_ev_time_frames = ev.time();
+	_flags = Source::Flag (_flags & ~Empty);
+}
+
+XMLNode&
+SMFSource::get_state ()
+{
+	XMLNode& node = MidiSource::get_state();
+	node.add_property (X_("origin"), _origin);
+	return node;
+}
+
+int
+SMFSource::set_state (const XMLNode& node, int version)
+{
+	if (Source::set_state (node, version)) {
+		return -1;
+	}
+
+	if (MidiSource::set_state (node, version)) {
+		return -1;
+	}
+
+	if (FileSource::set_state (node, version)) {
+		return -1;
+	}
+
+	return 0;
+}
+
+void
+SMFSource::mark_streaming_midi_write_started (NoteMode mode)
+{
+	/* CALLER MUST HOLD LOCK */
+
+	if (!_open && open_for_write()) {
+		error << string_compose (_("cannot open MIDI file %1 for write"), _path) << endmsg;
+		/* XXX should probably throw or return something */
+		return;
+	}
+
+	MidiSource::mark_streaming_midi_write_started (mode);
+	Evoral::SMF::begin_write ();
+	_last_ev_time_beats = 0.0;
+	_last_ev_time_frames = 0;
+}
+
+void
+SMFSource::mark_streaming_write_completed ()
+{
+	mark_midi_streaming_write_completed (Evoral::Sequence<Evoral::MusicalTime>::DeleteStuckNotes);
+}
+
+void
+SMFSource::mark_midi_streaming_write_completed (Evoral::Sequence<Evoral::MusicalTime>::StuckNoteOption stuck_notes_option, Evoral::MusicalTime when)
+{
+	Glib::Threads::Mutex::Lock lm (_lock);
+	MidiSource::mark_midi_streaming_write_completed (stuck_notes_option, when);
+
+	if (!writable()) {
+		warning << string_compose ("attempt to write to unwritable SMF file %1", _path) << endmsg;
+		return;
+	}
+
+	if (_model) {
+		_model->set_edited(false);
+	}
+
+	Evoral::SMF::end_write ();
+
+	/* data in the file now, not removable */
+
+	mark_nonremovable ();
+}
+
+bool
+SMFSource::valid_midi_file (const string& file)
+{
+	if (safe_midi_file_extension (file) ) {
+		return (SMF::test (file) );
+	}
+	return false;
+}
+
+bool
+SMFSource::safe_midi_file_extension (const string& file)
+{
+	static regex_t compiled_pattern;
+	static bool compile = true;
+	const int nmatches = 2;
+	regmatch_t matches[nmatches];
+	
+	if (Glib::file_test (file, Glib::FILE_TEST_EXISTS)) {
+		if (!Glib::file_test (file, Glib::FILE_TEST_IS_REGULAR)) {
+			/* exists but is not a regular file */
+			return false;
+		}
+	}
+
+	if (compile && regcomp (&compiled_pattern, "\\.[mM][iI][dD][iI]?$", REG_EXTENDED)) {
+		return false;
+	} else {
+		compile = false;
+	}
+	
+	if (regexec (&compiled_pattern, file.c_str(), nmatches, matches, 0)) {
+		return false;
+	}
+
+	return true;
+}
+
+static bool compare_eventlist (
+		const std::pair< Evoral::Event<double>*, gint >& a,
+		const std::pair< Evoral::Event<double>*, gint >& b) {
+	return ( a.first->time() < b.first->time() );
+}
+
+void
+SMFSource::load_model (bool lock, bool force_reload)
+{
+	if (_writing) {
+		return;
+	}
+
+	boost::shared_ptr<Glib::Threads::Mutex::Lock> lm;
+	if (lock)
+		lm = boost::shared_ptr<Glib::Threads::Mutex::Lock>(new Glib::Threads::Mutex::Lock(_lock));
+
+	if (_model && !force_reload) {
+		return;
+	}
+
+	if (!_model) {
+		_model = boost::shared_ptr<MidiModel> (new MidiModel (shared_from_this ()));
+	} else {
+		_model->clear();
+	}
+
+	if (writable() && !_open) {
+		return;
+	}
+
+	_model->start_write();
+	Evoral::SMF::seek_to_start();
+
+	uint64_t time = 0; /* in SMF ticks */
+	Evoral::Event<double> ev;
+
+	uint32_t scratch_size = 0; // keep track of scratch and minimize reallocs
+
+	uint32_t delta_t = 0;
+	uint32_t size    = 0;
+	uint8_t* buf     = NULL;
+	int ret;
+	gint event_id;
+	bool have_event_id;
+
+	// TODO simplify event allocation
+	std::list< std::pair< Evoral::Event<double>*, gint > > eventlist;
+
+	for (unsigned i = 1; i <= num_tracks(); ++i) {
+		if (seek_to_track(i)) continue;
+
+		time = 0;
+		have_event_id = false;
+
+		while ((ret = read_event (&delta_t, &size, &buf, &event_id)) >= 0) {
+
+			time += delta_t;
+
+			if (ret == 0) {
+				/* meta-event : did we get an event ID ?  */
+				if (event_id >= 0) {
+					have_event_id = true;
+				}
+				continue;
+			}
+
+			if (ret > 0) {
+				/* not a meta-event */
+
+				if (!have_event_id) {
+					event_id = Evoral::next_event_id();
+				}
+				uint32_t event_type = EventTypeMap::instance().midi_event_type(buf[0]);
+				double   event_time = time / (double) ppqn();
+#ifndef NDEBUG
+				std::string ss;
+
+				for (uint32_t xx = 0; xx < size; ++xx) {
+					char b[8];
+					snprintf (b, sizeof (b), "0x%x ", buf[xx]);
+					ss += b;
+				}
+
+				DEBUG_TRACE (DEBUG::MidiSourceIO, string_compose ("SMF %6 load model delta %1, time %2, size %3 buf %4, type %5\n",
+							delta_t, time, size, ss , event_type, name()));
+#endif
+
+				eventlist.push_back(make_pair (
+							new Evoral::Event<double> (
+								event_type, event_time,
+								size, buf, true)
+							, event_id));
+
+				// Set size to max capacity to minimize allocs in read_event
+				scratch_size = std::max(size, scratch_size);
+				size = scratch_size;
+
+				_length_beats = max(_length_beats, event_time);
+			}
+
+			/* event ID's must immediately precede the event they are for */
+			have_event_id = false;
+		}
+	}
+
+	eventlist.sort(compare_eventlist);
+
+	std::list< std::pair< Evoral::Event<double>*, gint > >::iterator it;
+	for (it=eventlist.begin(); it!=eventlist.end(); ++it) {
+		_model->append (*it->first, it->second);
+		delete it->first;
+	}
+
+	_model->end_write (Evoral::Sequence<Evoral::MusicalTime>::ResolveStuckNotes, _length_beats);
+	_model->set_edited (false);
+
+	_model_iter = _model->begin();
+
+	free(buf);
+}
+
+void
+SMFSource::destroy_model ()
+{
+	//cerr << _name << " destroying model " << _model.get() << endl;
+	_model.reset();
+}
+
+void
+SMFSource::flush_midi ()
+{
+	if (!writable() || _length_beats == 0.0) {
+		return;
+	}
+
+	ensure_disk_file ();
+
+	Evoral::SMF::end_write ();
+	/* data in the file means its no longer removable */
+	mark_nonremovable ();
+}
+
+void
+SMFSource::set_path (const string& p)
+{
+	FileSource::set_path (p);
+	SMF::set_path (_path);
+}
+
+/** Ensure that this source has some file on disk, even if it's just a SMF header */
+void
+SMFSource::ensure_disk_file ()
+{
+	if (!writable()) {
+		return;
+	}
+
+	if (_model) {
+		/* We have a model, so write it to disk; see MidiSource::session_saved
+		   for an explanation of what we are doing here.
+		*/
+		boost::shared_ptr<MidiModel> mm = _model;
+		_model.reset ();
+		mm->sync_to_source ();
+		_model = mm;
+	} else {
+		/* No model; if it's not already open, it's an empty source, so create
+		   and open it for writing.
+		*/
+		if (!_open) {
+			open_for_write ();
+		}
+	}
+}
+
+void
+SMFSource::prevent_deletion ()
+{
+	/* Unlike the audio case, the MIDI file remains mutable (because we can
+	   edit MIDI data)
+	*/
+  
+	_flags = Flag (_flags & ~(Removable|RemovableIfEmpty|RemoveAtDestroy));
+}
+
 
=== modified file '.pc/wscript.patch/wscript'
--- .pc/wscript.patch/wscript	2014-01-24 16:31:54 +0000
+++ .pc/wscript.patch/wscript	2015-05-02 14:23:30 +0000
@@ -177,10 +177,6 @@
     if opt.gprofile:
         debug_flags = [ '-pg' ]
 
-    if opt.backtrace:
-        if platform != 'darwin' and not is_clang:
-            debug_flags = [ '-rdynamic' ]
-
     # Autodetect
     if opt.dist_target == 'auto':
         if platform == 'darwin':
@@ -415,6 +411,10 @@
         conf.env.append_value('CFLAGS', optimization_flags)
         conf.env.append_value('CXXFLAGS', optimization_flags)
 
+    if opt.backtrace:
+        if platform != 'darwin' and not is_clang:
+            linker_flags += [ '-rdynamic' ]
+
     conf.env.append_value('CFLAGS', compiler_flags)
     conf.env.append_value('CFLAGS', c_flags)
     conf.env.append_value('CXXFLAGS', compiler_flags)
 
=== modified file 'debian/changelog'
--- debian/changelog	2014-01-24 16:31:54 +0000
+++ debian/changelog	2015-05-02 14:23:30 +0000
@@ -1,15 +1,78 @@
-ardour3 (3.5.308~dfsg-1) unstable; urgency=low
-
-  [ Jaromír Mikeš ]
-  * Use higher resolution picture for desktop icon (Closes: #729890).
-
-  [ Adrian Knoth ]
-  * Change Name entry in desktop file (Closes: #729890)
-  * Remove python runtime dependencies
-  * Imported Upstream version 3.5.308~dfsg (Closes: #734079 #733969)
-
- -- Adrian Knoth <[e-mail]>  Fri, 24 Jan 2014 16:31:54 +0100
-
+<<<<<<< TREE
+ardour3 (3.5.308~dfsg-1) unstable; urgency=low
+
+  [ Jaromír Mikeš ]
+  * Use higher resolution picture for desktop icon (Closes: #729890).
+
+  [ Adrian Knoth ]
+  * Change Name entry in desktop file (Closes: #729890)
+  * Remove python runtime dependencies
+  * Imported Upstream version 3.5.308~dfsg (Closes: #734079 #733969)
+
+ -- Adrian Knoth <[e-mail]>  Fri, 24 Jan 2014 16:31:54 +0100
+
+=======
+ardour3 (3.5.403~dfsg-3) unstable; urgency=medium
+
+  * Fix MIDI data loss when editing (Closes: #772118)
+
+ -- Adrian Knoth <[e-mail]>  Thu, 04 Dec 2014 19:34:45 +0100
+
+ardour3 (3.5.403~dfsg-2) unstable; urgency=high
+
+  * Reupload with waf fixes from 3.5.380~dfsg-2 and -3 
+
+ -- Adrian Knoth <[e-mail]>  Fri, 03 Oct 2014 14:01:07 +0200
+
+ardour3 (3.5.403~dfsg-1) unstable; urgency=high
+
+  * Imported Upstream version 3.5.403~dfsg
+  * Critical bugfix release. All users are recommended to upgrade.
+  * Details: https://community.ardour.org/node/8457
+
+ -- Adrian Knoth <[e-mail]>  Fri, 03 Oct 2014 13:02:45 +0200
+
+ardour3 (3.5.380~dfsg-3) unstable; urgency=medium
+
+  * Prevent build failures in slower architectures by
+    forcing waf logging to stdout instead of stderr.
+
+ -- Felipe Sateler <[e-mail]>  Fri, 11 Jul 2014 12:46:37 -0400
+
+ardour3 (3.5.380~dfsg-2) unstable; urgency=medium
+
+  * Team upload.
+  * Pass correct -j flag to waf. Closes: #748584
+
+ -- Felipe Sateler <[e-mail]>  Mon, 16 Jun 2014 11:03:20 -0400
+
+ardour3 (3.5.380~dfsg-1) unstable; urgency=low
+
+  * Imported Upstream version 3.5.380~dfsg
+
+ -- Adrian Knoth <[e-mail]>  Thu, 15 May 2014 14:33:48 +0200
+
+ardour3 (3.5.357~dfsg-1) unstable; urgency=high
+
+  * Imported Upstream version 3.5.357~dfsg
+  * Critical bugfix release. All users are recommended to upgrade.
+  * Details: https://community.ardour.org/node/8015
+
+ -- Adrian Knoth <[e-mail]>  Tue, 25 Feb 2014 14:13:18 +0100
+
+ardour3 (3.5.308~dfsg-1) unstable; urgency=low
+
+  [ Jaromír Mikeš ]
+  * Use higher resolution picture for desktop icon (Closes: #729890).
+
+  [ Adrian Knoth ]
+  * Change Name entry in desktop file (Closes: #729890)
+  * Remove python runtime dependencies
+  * Imported Upstream version 3.5.308~dfsg (Closes: #734079 #733969)
+
+ -- Adrian Knoth <[e-mail]>  Fri, 24 Jan 2014 16:31:54 +0100
+
+>>>>>>> MERGE-SOURCE
 ardour3 (3.5.143~dfsg-1) unstable; urgency=low
 
   * Imported Upstream version 3.5.143~dfsg
 
=== modified file 'debian/control'
--- debian/control	2014-01-24 16:31:54 +0000
+++ debian/control	2015-05-02 14:23:30 +0000
@@ -47,9 +47,15 @@
  vamp-plugin-sdk (>=2.1),
  python-setuptools,
  python-isodate,
+<<<<<<< TREE
  libpcre3-dev,
  python-rdflib
 Standards-Version: 3.9.4
+=======
+ libpcre3-dev,
+ python-rdflib
+Standards-Version: 3.9.6
+>>>>>>> MERGE-SOURCE
 Homepage: http://www.ardour.org/
 Vcs-Git: git://anonscm.debian.org/pkg-multimedia/ardour3.git
 Vcs-Browser: http://anonscm.debian.org/gitweb/?p=pkg-multimedia/ardour3.git
 
=== modified file 'debian/control.in'
--- debian/control.in	2014-01-24 16:31:54 +0000
+++ debian/control.in	2015-05-02 14:23:30 +0000
@@ -7,7 +7,7 @@
  Jaromír Mikeš <[e-mail]>
 Build-Depends:
  @cdbs@
-Standards-Version: 3.9.4
+Standards-Version: 3.9.6
 Homepage: http://www.ardour.org/
 Vcs-Git: git://anonscm.debian.org/pkg-multimedia/ardour3.git
 Vcs-Browser: http://anonscm.debian.org/gitweb/?p=pkg-multimedia/ardour3.git
 
=== added file 'debian/patches/log-stdout.patch'
--- debian/patches/log-stdout.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/log-stdout.patch	2015-05-02 14:23:30 +0000
@@ -0,0 +1,25 @@
+Description: Log waf messages to stdout, not stderr
+ The buildds kill the build if they don't see messages in stdout for a
+ long time. Unfortunately, waf defaults to printing such messages to
+ stderr, so ardour takes too long on slower archs. Work around that
+ by printing to stdout.
+Author: Felipe Sateler <[e-mail]>
+Forwarded: no
+--- ardour3-3.5.380~dfsg.orig/wscript
++++ ardour3-3.5.380~dfsg/wscript
+@@ -777,6 +777,15 @@ const char* const ardour_config_info = "
+ def build(bld):
+     create_stored_revision()
+ 
++    # Log command executions to stdout, not err
++    def our_log(msg):
++        if not msg:
++            return
++        sys.stdout.write(str(msg))
++        sys.stdout.flush()
++
++    bld.to_log = our_log
++
+     # add directories that contain only headers, to workaround an issue with waf
+ 
+     bld.path.find_dir ('libs/evoral/evoral')
 
=== added file 'debian/patches/midi-data-loss.patch'
--- debian/patches/midi-data-loss.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/midi-data-loss.patch	2015-05-02 14:23:30 +0000
@@ -0,0 +1,62 @@
+From: David Robillard <[e-mail]>
+Description: Fix MIDI data loss when editing
+Forwarded: not-needed
+Last-Update: 2014-12-04
+Bug-Vendor: http://tracker.ardour.org/view.php?id=5669
+Applied-Upstream: 3.5.404; https://github.com/Ardour/ardour/commit/94954f852ead97bcda7afa548d543222733228ef
+--- ardour3.orig/libs/ardour/smf_source.cc
++++ ardour3/libs/ardour/smf_source.cc
+@@ -393,10 +393,22 @@ SMFSource::append_event_unlocked_beats (
+                name().c_str(), ev.id(), ev.time(), ev.size());
+ 	       for (size_t i = 0; i < ev.size(); ++i) printf("%X ", ev.buffer()[i]); printf("\n");*/
+ 
+-	if (ev.time() < _last_ev_time_beats) {
+-		warning << string_compose(_("Skipping event with unordered time %1"), ev.time())
+-		        << endmsg;
+-		return;
++	double time = ev.time();
++	if (time < _last_ev_time_beats) {
++		const double difference = _last_ev_time_beats - time;
++		if (difference / (double)ppqn() < 1.0) {
++			/* Close enough.  This problem occurs because Sequence is not
++			   actually ordered due to fuzzy time comparison.  I'm pretty sure
++			   this is inherently a bad idea which causes problems all over the
++			   place, but tolerate it here for now anyway. */
++			time = _last_ev_time_beats;
++		} else {
++			/* Out of order by more than a tick. */
++			warning << string_compose(_("Skipping event with unordered beat time %1 < %2 (off by %3 beats, %4 ticks)"),
++			                          ev.time(), _last_ev_time_beats, difference, difference / (double)ppqn())
++			        << endmsg;
++			return;
++		}
+ 	}
+ 
+ 	Evoral::event_id_t event_id;
+@@ -411,13 +423,13 @@ SMFSource::append_event_unlocked_beats (
+ 		_model->append (ev, event_id);
+ 	}
+ 
+-	_length_beats = max(_length_beats, ev.time());
++	_length_beats = max(_length_beats, time);
+ 
+-	const double delta_time_beats   = ev.time() - _last_ev_time_beats;
++	const double delta_time_beats   = time - _last_ev_time_beats;
+ 	const uint32_t delta_time_ticks = (uint32_t)lrint(delta_time_beats * (double)ppqn());
+ 
+ 	Evoral::SMF::append_event_delta(delta_time_ticks, ev.size(), ev.buffer(), event_id);
+-	_last_ev_time_beats = ev.time();
++	_last_ev_time_beats = time;
+ 	_flags = Source::Flag (_flags & ~Empty);
+ }
+ 
+@@ -434,7 +446,8 @@ SMFSource::append_event_unlocked_frames
+ 	// for (size_t i=0; i < ev.size(); ++i) printf("%X ", ev.buffer()[i]); printf("\n");
+ 
+ 	if (ev.time() < _last_ev_time_frames) {
+-		warning << string_compose(_("Skipping event with unordered time %1"), ev.time())
++		warning << string_compose(_("Skipping event with unordered frame time %1 < %2"),
++		                          ev.time(), _last_ev_time_frames)
+ 		        << endmsg;
+ 		return;
+ 	}
 
=== modified file 'debian/patches/series'
--- debian/patches/series	2013-11-06 13:22:44 +0000
+++ debian/patches/series	2015-05-02 14:23:30 +0000
@@ -1,2 +1,4 @@
 waf.patch
 wscript.patch
+log-stdout.patch
+midi-data-loss.patch
 
=== modified file 'debian/rules'
--- debian/rules	2014-01-24 16:31:54 +0000
+++ debian/rules	2015-05-02 14:23:30 +0000
@@ -37,7 +37,8 @@
 	--optimize \
 
 
-DEB_MAKE_EXTRA_ARGS = -v --destdir=$(CURDIR)/debian/tmp
+DEB_MAKE_PARALLEL = -j$(if $(DEB_PARALLEL_JOBS),$(DEB_PARALLEL_JOBS),1)
+DEB_MAKE_EXTRA_ARGS = -v --destdir=$(CURDIR)/debian/tmp $(DEB_MAKE_PARALLEL)
 DEB_MAKE_BUILD_TARGET = build i18n_mo
 DEB_MAKE_ENVVARS = CFLAGS="$(or $(CFLAGS_$(cdbs_curpkg)),$(CFLAGS))" CXXFLAGS="$(or $(CXXFLAGS_$(cdbs_curpkg)),$(CXXFLAGS))" CPPFLAGS="$(or $(CPPFLAGS_$(cdbs_curpkg)),$(CPPFLAGS))" LDFLAGS="$(or $(LDFLAGS_$(cdbs_curpkg)),$(LDFLAGS))"
 DEB_MAKE_INVOKE = $(DEB_MAKE_ENVVARS) $(CURDIR)/waf-light $(DEB_MAKE_EXTRA_ARGS)
 
=== modified file 'gtk2_ardour/add_video_dialog.cc'
--- gtk2_ardour/add_video_dialog.cc	2013-09-21 19:05:02 +0000
+++ gtk2_ardour/add_video_dialog.cc	2015-05-02 14:23:30 +0000
@@ -258,7 +258,8 @@
 		".ogg"     , ".OGG"     ,
 		".ogv"     , ".OGV"     ,
 		".mpg"     , ".MPG"     ,
-		".mov"     , ".MOV"     ,
+		".mpeg"    , ".MPEG"    ,
+		".mts"     , ".MTS"    ,
 		".mp4"     , ".MP4"     ,
 		".mkv"     , ".MKV"     ,
 		".vob"     , ".VOB"     ,
@@ -272,6 +273,8 @@
 		".dv"      , ".DV"      ,
 		".dirac"   , ".DIRAC"   ,
 		".webm"    , ".WEBM"    ,
+		".wmv"     , ".wmv"     ,
+		".ts"      , ".ts"      ,
 	};
 
 	for (size_t n = 0; n < sizeof(suffixes)/sizeof(suffixes[0]); ++n) {
 
=== modified file 'gtk2_ardour/ardev_common.sh.in'
--- gtk2_ardour/ardev_common.sh.in	2014-01-24 16:31:54 +0000
+++ gtk2_ardour/ardev_common.sh.in	2015-05-02 14:23:30 +0000
@@ -18,6 +18,7 @@
 export ARDOUR_MCP_PATH=$TOP/mcp:.
 export ARDOUR_EXPORT_FORMATS_PATH=$TOP/export:.
 export ARDOUR_BACKEND_PATH=$libs/backends/jack
+export ARDOUR_TEST_PATH=$libs/ardour/test/data
 
 #
 # even though we set the above variables, ardour requires that these 
 
=== modified file 'gtk2_ardour/ardour.menus.in'
--- gtk2_ardour/ardour.menus.in	2014-01-24 16:31:54 +0000
+++ gtk2_ardour/ardour.menus.in	2015-05-02 14:23:30 +0000
@@ -341,6 +341,7 @@
 
     <menu name='View' action = 'View'>
       <menuitem action='ToggleMaximalEditor'/>
+      <menuitem action='ToggleMaximalMixer'/>
       <menuitem action='KeepTearoffs'/>
 
       <separator/>
 
=== modified file 'gtk2_ardour/ardour_ui.cc'
--- gtk2_ardour/ardour_ui.cc	2014-01-24 16:31:54 +0000
+++ gtk2_ardour/ardour_ui.cc	2015-05-02 14:23:30 +0000
@@ -496,10 +496,13 @@
 
 		vector<string>::iterator n;
 		vector<string>::iterator k;
-		for (n = names.begin(), k = keys.begin(); n != names.end(); ++n, ++k) {
-			cout << "Action: " << (*n) << " bound to " << (*k) << endl;
+		vector<string>::iterator p;
+		for (n = names.begin(), k = keys.begin(), p = paths.begin(); n != names.end(); ++n, ++k, ++p) {
+			cout << "Action: '" << (*n) << "' bound to '" << (*k) << "' Path: '" << (*p) << "'" << endl;
 		}
 
+		halt_connection.disconnect ();
+		AudioEngine::instance()->stop ();
 		exit (0);
 	}
 
@@ -3264,7 +3267,7 @@
 	} else {
 		for (TrackSelection::iterator s = editor->get_selection().tracks.begin(); s != editor->get_selection().tracks.end(); ++s) {
 			RouteTimeAxisView* tav = dynamic_cast<RouteTimeAxisView*> (*s);
-			if (tav->route()->order_key() > order_hint) {
+			if (tav && tav->route() && tav->route()->order_key() > order_hint) {
 				order_hint = tav->route()->order_key();
 			}
 		}
 
=== modified file 'gtk2_ardour/ardour_ui.h'
--- gtk2_ardour/ardour_ui.h	2013-11-06 13:22:44 +0000
+++ gtk2_ardour/ardour_ui.h	2015-05-02 14:23:30 +0000
@@ -171,6 +171,7 @@
 
 	void new_midi_tracer_window ();
 	void toggle_editing_space();
+	void toggle_mixer_space();
 	void toggle_keep_tearoffs();
 
 	Gtk::Tooltips& tooltips() { return _tooltips; }
 
=== modified file 'gtk2_ardour/ardour_ui_dialogs.cc'
--- gtk2_ardour/ardour_ui_dialogs.cc	2013-12-23 22:07:52 +0000
+++ gtk2_ardour/ardour_ui_dialogs.cc	2015-05-02 14:23:30 +0000
@@ -565,3 +565,18 @@
 	}
 	return true;
 }
+
+void
+ARDOUR_UI::toggle_mixer_space()
+{
+	Glib::RefPtr<Action> act = ActionManager::get_action ("Common", "ToggleMaximalMixer");
+
+	if (act) {
+		Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
+		if (tact->get_active()) {
+			mixer->maximise_mixer_space ();
+		} else {
+			mixer->restore_mixer_space ();
+		}
+	}
+}
 
=== modified file 'gtk2_ardour/ardour_ui_ed.cc'
--- gtk2_ardour/ardour_ui_ed.cc	2013-10-17 11:16:21 +0000
+++ gtk2_ardour/ardour_ui_ed.cc	2015-05-02 14:23:30 +0000
@@ -191,6 +191,7 @@
 	/* windows visibility actions */
 
 	ActionManager::register_toggle_action (common_actions, X_("ToggleMaximalEditor"), _("Maximise Editor Space"), sigc::mem_fun (*this, &ARDOUR_UI::toggle_editing_space));
+	ActionManager::register_toggle_action (common_actions, X_("ToggleMaximalMixer"), _("Maximise Mixer Space"), sigc::mem_fun (*this, &ARDOUR_UI::toggle_mixer_space));
 	act = ActionManager::register_toggle_action (common_actions, X_("KeepTearoffs"), _("Show Toolbars"), mem_fun (*this, &ARDOUR_UI::toggle_keep_tearoffs));
 	ActionManager::session_sensitive_actions.push_back (act);
 
 
=== modified file 'gtk2_ardour/audio_region_view.cc'
--- gtk2_ardour/audio_region_view.cc	2013-09-21 19:05:02 +0000
+++ gtk2_ardour/audio_region_view.cc	2015-05-02 14:23:30 +0000
@@ -963,7 +963,7 @@
 }
 
 void
-AudioRegionView::add_gain_point_event (ArdourCanvas::Item *item, GdkEvent *ev)
+AudioRegionView::add_gain_point_event (ArdourCanvas::Item *item, GdkEvent *ev, bool with_guard_points)
 {
 	if (!gain_line) {
 		return;
@@ -1008,7 +1008,7 @@
 		trackview.session()->add_command (new MementoCommand<AudioRegion>(*(audio_region().get()), &region_before, &region_after));
 	}
 
-	audio_region()->envelope()->add (fx, y);
+	audio_region()->envelope()->add (fx, y, with_guard_points);
 
 	XMLNode &after = audio_region()->envelope()->get_state();
 	trackview.session()->add_command (new MementoCommand<AutomationList>(*audio_region()->envelope().get(), &before, &after));
 
=== modified file 'gtk2_ardour/audio_region_view.h'
--- gtk2_ardour/audio_region_view.h	2013-09-21 19:05:02 +0000
+++ gtk2_ardour/audio_region_view.h	2015-05-02 14:23:30 +0000
@@ -81,7 +81,7 @@
 
 	void update_envelope_visibility ();
 
-	void add_gain_point_event (ArdourCanvas::Item *item, GdkEvent *event);
+        void add_gain_point_event (ArdourCanvas::Item *item, GdkEvent *event, bool with_guard_points);
 	void remove_gain_point_event (ArdourCanvas::Item *item, GdkEvent *event);
 
 	boost::shared_ptr<AudioRegionGainLine> get_gain_line() const { return gain_line; }
 
=== modified file 'gtk2_ardour/automation_region_view.cc'
--- gtk2_ardour/automation_region_view.cc	2013-09-21 19:05:02 +0000
+++ gtk2_ardour/automation_region_view.cc	2015-05-02 14:23:30 +0000
@@ -27,6 +27,8 @@
 #include "ardour/midi_region.h"
 #include "ardour/session.h"
 
+#include "gtkmm2ext/keyboard.h"
+
 #include "automation_region_view.h"
 #include "editing.h"
 #include "editor.h"
@@ -120,7 +122,11 @@
 		y = std::max (y, 0.0);
 		y = std::min (y, _height - NAME_HIGHLIGHT_SIZE);
 
-		add_automation_event (ev, trackview.editor().pixel_to_frame (x) - _region->position() + _region->start(), y);
+		/* guard points only if primary modifier is used */
+
+		bool with_guard_points = Gtkmm2ext::Keyboard::modifier_state_equals (ev->button.state, Gtkmm2ext::Keyboard::PrimaryModifier);
+
+		add_automation_event (ev, trackview.editor().pixel_to_frame (x) - _region->position() + _region->start(), y, with_guard_points);
 	}
 
 	return false;
@@ -130,7 +136,7 @@
  *  @param y y position, relative to our TimeAxisView.
  */
 void
-AutomationRegionView::add_automation_event (GdkEvent *, framepos_t when, double y)
+AutomationRegionView::add_automation_event (GdkEvent *, framepos_t when, double y, bool with_guard_points)
 {
 	if (!_line) {
 		boost::shared_ptr<Evoral::Control> c = _region->control(_parameter, true);
@@ -160,7 +166,7 @@
 	view->session()->begin_reversible_command (_("add automation event"));
 	XMLNode& before = _line->the_list()->get_state();
 
-	_line->the_list()->add (when_d, y);
+	_line->the_list()->add (when_d, y, with_guard_points);
 
 	XMLNode& after = _line->the_list()->get_state();
 
 
=== modified file 'gtk2_ardour/automation_region_view.h'
--- gtk2_ardour/automation_region_view.h	2013-09-21 19:05:02 +0000
+++ gtk2_ardour/automation_region_view.h	2015-05-02 14:23:30 +0000
@@ -66,7 +66,7 @@
 	bool set_position(framepos_t pos, void* src, double* ignored);
 	void region_resized (const PBD::PropertyChange&);
 	bool canvas_event(GdkEvent* ev);
-	void add_automation_event (GdkEvent* event, framepos_t when, double y);
+        void add_automation_event (GdkEvent* event, framepos_t when, double y, bool with_guard_points);
 	void entered (bool);
 	void exited();
 
 
=== modified file 'gtk2_ardour/automation_time_axis.cc'
--- gtk2_ardour/automation_time_axis.cc	2013-09-21 19:05:02 +0000
+++ gtk2_ardour/automation_time_axis.cc	2015-05-02 14:23:30 +0000
@@ -550,7 +550,7 @@
 }
 
 void
-AutomationTimeAxisView::add_automation_event (GdkEvent* event, framepos_t when, double y)
+AutomationTimeAxisView::add_automation_event (GdkEvent* event, framepos_t when, double y, bool with_guard_points)
 {
 	if (!_line) {
 		return;
@@ -583,7 +583,7 @@
 	_session->begin_reversible_command (_("add automation event"));
 	XMLNode& before = list->get_state();
 
-	list->add (when, y);
+	list->add (when, y, with_guard_points);
 
 	XMLNode& after = list->get_state();
 	_session->commit_reversible_command (new MementoCommand<ARDOUR::AutomationList> (*list, &before, &after));
 
=== modified file 'gtk2_ardour/automation_time_axis.h'
--- gtk2_ardour/automation_time_axis.h	2013-09-21 19:05:02 +0000
+++ gtk2_ardour/automation_time_axis.h	2015-05-02 14:23:30 +0000
@@ -72,7 +72,7 @@
 	void set_samples_per_unit (double);
 	std::string name() const { return _name; }
 
-	void add_automation_event (GdkEvent *, framepos_t, double);
+        void add_automation_event (GdkEvent *, framepos_t, double, bool with_guard_points);
 
 	void clear_lines ();
 
 
=== modified file 'gtk2_ardour/editor.bindings'
--- gtk2_ardour/editor.bindings	2013-09-21 19:05:02 +0000
+++ gtk2_ardour/editor.bindings	2015-05-02 14:23:30 +0000
@@ -167,6 +167,7 @@
   <Binding action="Editor/pitch-shift-region" key="F5"/>
   <Binding action="Editor/select-range-between-cursors" key="F6"/>
   <Binding action="Common/ToggleMaximalEditor" key="F11"/>
+  <Binding action="Common/ToggleMaximalMixer" key="F12"/>
   <Binding action="Editor/save-visual-state-1" key="Primary-F1"/>
   <Binding action="Editor/save-visual-state-2" key="Primary-F2"/>
   <Binding action="Editor/save-visual-state-3" key="Primary-F3"/>
 
=== modified file 'gtk2_ardour/editor.h'
--- gtk2_ardour/editor.h	2014-01-24 16:31:54 +0000
+++ gtk2_ardour/editor.h	2015-05-02 14:23:30 +0000
@@ -1262,7 +1262,7 @@
 			 int target_regions, int target_tracks, boost::shared_ptr<ARDOUR::Track>&, bool add_channel_suffix);
 
 	int finish_bringing_in_material (boost::shared_ptr<ARDOUR::Region> region, uint32_t, uint32_t,  framepos_t& pos, Editing::ImportMode mode,
-				      boost::shared_ptr<ARDOUR::Track>& existing_track);
+					 boost::shared_ptr<ARDOUR::Track>& existing_track, const std::string& new_track_name);
 
 	boost::shared_ptr<ARDOUR::AudioTrack> get_nth_selected_audio_track (int nth) const;
 	boost::shared_ptr<ARDOUR::MidiTrack> get_nth_selected_midi_track (int nth) const;
 
=== modified file 'gtk2_ardour/editor_actions.cc'
--- gtk2_ardour/editor_actions.cc	2013-09-21 19:05:02 +0000
+++ gtk2_ardour/editor_actions.cc	2015-05-02 14:23:30 +0000
@@ -1143,94 +1143,94 @@
 {
 	switch (_snap_type) {
 	case Editing::SnapToCDFrame:
-		set_snap_to (Editing::SnapToTimecodeFrame);
+		set_snap_to (Editing::SnapToRegionBoundary);
 		break;
 	case Editing::SnapToTimecodeFrame:
-		set_snap_to (Editing::SnapToTimecodeSeconds);
+		set_snap_to (Editing::SnapToCDFrame);
 		break;
 	case Editing::SnapToTimecodeSeconds:
-		set_snap_to (Editing::SnapToTimecodeMinutes);
+		set_snap_to (Editing::SnapToTimecodeFrame);
 		break;
 	case Editing::SnapToTimecodeMinutes:
-		set_snap_to (Editing::SnapToSeconds);
+		set_snap_to (Editing::SnapToTimecodeSeconds);
 		break;
 	case Editing::SnapToSeconds:
-		set_snap_to (Editing::SnapToMinutes);
+		set_snap_to (Editing::SnapToTimecodeMinutes);
 		break;
 	case Editing::SnapToMinutes:
-		set_snap_to (Editing::SnapToBeatDiv128);
+		set_snap_to (Editing::SnapToSeconds);
 		break;
 	case Editing::SnapToBeatDiv128:
-		set_snap_to (Editing::SnapToBeatDiv64);
+		set_snap_to (Editing::SnapToMinutes);
 		break;
 	case Editing::SnapToBeatDiv64:
-		set_snap_to (Editing::SnapToBeatDiv32);
+		set_snap_to (Editing::SnapToBeatDiv128);
 		break;
 	case Editing::SnapToBeatDiv32:
-		set_snap_to (Editing::SnapToBeatDiv28);
+		set_snap_to (Editing::SnapToBeatDiv64);
 		break;
 	case Editing::SnapToBeatDiv28:
-		set_snap_to (Editing::SnapToBeatDiv24);
+		set_snap_to (Editing::SnapToBeatDiv32);
 		break;
 	case Editing::SnapToBeatDiv24:
-		set_snap_to (Editing::SnapToBeatDiv20);
+		set_snap_to (Editing::SnapToBeatDiv28);
 		break;
 	case Editing::SnapToBeatDiv20:
-		set_snap_to (Editing::SnapToBeatDiv16);
+		set_snap_to (Editing::SnapToBeatDiv24);
 		break;
 	case Editing::SnapToBeatDiv16:
-		set_snap_to (Editing::SnapToBeatDiv14);
+		set_snap_to (Editing::SnapToBeatDiv20);
 		break;
 	case Editing::SnapToBeatDiv14:
-		set_snap_to (Editing::SnapToBeatDiv12);
+		set_snap_to (Editing::SnapToBeatDiv16);
 		break;
 	case Editing::SnapToBeatDiv12:
-		set_snap_to (Editing::SnapToBeatDiv10);
+		set_snap_to (Editing::SnapToBeatDiv14);
 		break;
 	case Editing::SnapToBeatDiv10:
-		set_snap_to (Editing::SnapToBeatDiv8);
+		set_snap_to (Editing::SnapToBeatDiv12);
 		break;
 	case Editing::SnapToBeatDiv8:
-		set_snap_to (Editing::SnapToBeatDiv7);
+		set_snap_to (Editing::SnapToBeatDiv10);
 		break;
 	case Editing::SnapToBeatDiv7:
-		set_snap_to (Editing::SnapToBeatDiv6);
+		set_snap_to (Editing::SnapToBeatDiv8);
 		break;
 	case Editing::SnapToBeatDiv6:
-		set_snap_to (Editing::SnapToBeatDiv5);
+		set_snap_to (Editing::SnapToBeatDiv7);
 		break;
 	case Editing::SnapToBeatDiv5:
-		set_snap_to (Editing::SnapToBeatDiv4);
+		set_snap_to (Editing::SnapToBeatDiv6);
 		break;
 	case Editing::SnapToBeatDiv4:
-		set_snap_to (Editing::SnapToBeatDiv3);
+		set_snap_to (Editing::SnapToBeatDiv5);
 		break;
 	case Editing::SnapToBeatDiv3:
-		set_snap_to (Editing::SnapToBeatDiv2);
+		set_snap_to (Editing::SnapToBeatDiv4);
 		break;
 	case Editing::SnapToBeatDiv2:
-		set_snap_to (Editing::SnapToBeat);
+		set_snap_to (Editing::SnapToBeatDiv3);
 		break;
 	case Editing::SnapToBeat:
-		set_snap_to (Editing::SnapToBar);
+		set_snap_to (Editing::SnapToBeatDiv2);
 		break;
 	case Editing::SnapToBar:
-		set_snap_to (Editing::SnapToMark);
+		set_snap_to (Editing::SnapToBeat);
 		break;
 	case Editing::SnapToMark:
-		set_snap_to (Editing::SnapToRegionStart);
+		set_snap_to (Editing::SnapToBar);
 		break;
 	case Editing::SnapToRegionStart:
-		set_snap_to (Editing::SnapToRegionEnd);
+		set_snap_to (Editing::SnapToMark);
 		break;
 	case Editing::SnapToRegionEnd:
-		set_snap_to (Editing::SnapToRegionSync);
+		set_snap_to (Editing::SnapToRegionStart);
 		break;
 	case Editing::SnapToRegionSync:
-		set_snap_to (Editing::SnapToRegionBoundary);
+		set_snap_to (Editing::SnapToRegionEnd);
 		break;
 	case Editing::SnapToRegionBoundary:
-		set_snap_to (Editing::SnapToCDFrame);
+		set_snap_to (Editing::SnapToRegionSync);
 		break;
 	}
 }
 
=== modified file 'gtk2_ardour/editor_audio_import.cc'
--- gtk2_ardour/editor_audio_import.cc	2014-01-24 16:31:54 +0000
+++ gtk2_ardour/editor_audio_import.cc	2015-05-02 14:23:30 +0000
@@ -611,7 +611,7 @@
 
 				boost::shared_ptr<Source> s;
 
-				if ((s = _session->source_by_path_and_channel (path, n)) == 0) {
+				if ((s = _session->audio_source_by_path_and_channel (path, n)) == 0) {
 
 					source = boost::dynamic_pointer_cast<AudioFileSource> (
 						SourceFactory::createExternal (DataType::AUDIO, *_session,
@@ -657,7 +657,8 @@
 	uint32_t input_chan = 0;
 	uint32_t output_chan = 0;
 	bool use_timestamp;
-	
+	vector<string> track_names;
+
 	use_timestamp = (pos == -1);
 
 	// kludge (for MIDI we're abusing "channel" for "track" here)
@@ -694,6 +695,11 @@
 
 		regions.push_back (r);
 
+		/* if we're creating a new track, name it after the cleaned-up
+		 * and "merged" region name.
+		 */
+
+		track_names.push_back (region_name);
 
 	} else if (target_regions == -1 || target_regions > 1) {
 
@@ -724,29 +730,26 @@
 					region_name = (*x)->name();
 				}
 				
-				switch (sources.size()) {
-					/* zero and one channel handled
-					   by previous if() condition
-					*/
-				case 2:
+				if (sources.size() == 2) {
 					if (n == 0) {
 						region_name += "-L";
 					} else {
 						region_name += "-R";
 					}
-					break;
-				default:
-					region_name += (char) '-';
-					region_name += (char) ('1' + n);
-					break;
+				} else if (sources.size() > 2) {
+					region_name += string_compose ("-%1", n+1);
 				}
 				
+				track_names.push_back (region_name);
+				
 			} else {
 				if (fs) {
 					region_name = region_name_from_path (fs->path(), false, false, sources.size(), n);
-				} else{
+				} else {
 					region_name = (*x)->name();
 				}
+
+				track_names.push_back (PBD::basename_nosuffix (paths[n]));
 			}
 
 			PropertyList plist;
@@ -798,6 +801,12 @@
 	framepos_t rlen = 0;
 
 	begin_reversible_command (Operations::insert_file);
+
+	/* we only use tracks names when importing to new tracks, but we
+	 * require that one is defined for every region, just to keep
+	 * the API simpler.
+	 */
+	assert (regions.size() == track_names.size());
 	
 	for (vector<boost::shared_ptr<Region> >::iterator r = regions.begin(); r != regions.end(); ++r, ++n) {
 		boost::shared_ptr<AudioRegion> ar = boost::dynamic_pointer_cast<AudioRegion> (*r);
@@ -830,9 +839,8 @@
                                 pos = get_preferred_edit_position ();
                         }
                 }
-
-
-		finish_bringing_in_material (*r, input_chan, output_chan, pos, mode, track);
+		
+		finish_bringing_in_material (*r, input_chan, output_chan, pos, mode, track, track_names[n]);
 
 		rlen = (*r)->length();
 
@@ -859,7 +867,7 @@
 
 int
 Editor::finish_bringing_in_material (boost::shared_ptr<Region> region, uint32_t in_chans, uint32_t out_chans, framepos_t& pos,
-				     ImportMode mode, boost::shared_ptr<Track>& existing_track)
+				     ImportMode mode, boost::shared_ptr<Track>& existing_track, const string& new_track_name)
 {
 	boost::shared_ptr<AudioRegion> ar = boost::dynamic_pointer_cast<AudioRegion>(region);
 	boost::shared_ptr<MidiRegion> mr = boost::dynamic_pointer_cast<MidiRegion>(region);
@@ -916,7 +924,11 @@
 				existing_track = mt.front();
 			}
 
-			existing_track->set_name (region->name());
+			if (!new_track_name.empty()) {
+				existing_track->set_name (new_track_name);
+			} else {
+				existing_track->set_name (region->name());
+			}
 		}
 
 		boost::shared_ptr<Playlist> playlist = existing_track->playlist();
 
=== modified file 'gtk2_ardour/editor_drag.cc'
--- gtk2_ardour/editor_drag.cc	2013-11-06 13:22:44 +0000
+++ gtk2_ardour/editor_drag.cc	2015-05-02 14:23:30 +0000
@@ -3275,10 +3275,24 @@
 }
 
 void
-LineDrag::finished (GdkEvent* event, bool)
+LineDrag::finished (GdkEvent* event, bool movement_occured)
 {
-	motion (event, false);
-	_line->end_drag (false, 0);
+	if (movement_occured) {
+		motion (event, false);
+		_line->end_drag (false, 0);
+	} else {
+		/* add a new control point on the line */
+
+		AutomationTimeAxisView* atv;
+
+		_line->end_drag (false, 0);
+
+		if ((atv = dynamic_cast<AutomationTimeAxisView*>(_editor->clicked_axisview)) != 0) {
+			framepos_t where = _editor->event_frame (event, 0, 0);
+			atv->add_automation_event (event, where, event->button.y, false);
+		}
+	}
+
 	_editor->session()->commit_reversible_command ();
 }
 
 
=== modified file 'gtk2_ardour/editor_mouse.cc'
--- gtk2_ardour/editor_mouse.cc	2013-11-06 13:22:44 +0000
+++ gtk2_ardour/editor_mouse.cc	2015-05-02 14:23:30 +0000
@@ -1682,7 +1682,8 @@
 			case AutomationTrackItem:
 				atv = dynamic_cast<AutomationTimeAxisView*>(clicked_axisview);
 				if (atv) {
-					atv->add_automation_event (event, where, event->button.y);
+					bool with_guard_points = Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier);
+					atv->add_automation_event (event, where, event->button.y, with_guard_points);
 				}
 				return true;
 				break;
@@ -1701,17 +1702,20 @@
 				*/
 				AudioRegionView* arv = dynamic_cast<AudioRegionView*> (clicked_regionview);
 				if (!were_dragging && arv) {
-					arv->add_gain_point_event (item, event);
+					bool with_guard_points = Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier);
+					arv->add_gain_point_event (item, event, with_guard_points);
 				}
 				return true;
 				break;
 			}
 
-			case AutomationTrackItem:
+			case AutomationTrackItem: {
+				bool with_guard_points = Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier);
 				dynamic_cast<AutomationTimeAxisView*>(clicked_axisview)->
-					add_automation_event (event, where, event->button.y);
+					add_automation_event (event, where, event->button.y, with_guard_points);
 				return true;
 				break;
+			}
 			default:
 				break;
 			}
 
=== modified file 'gtk2_ardour/editor_ops.cc'
--- gtk2_ardour/editor_ops.cc	2013-11-06 13:22:44 +0000
+++ gtk2_ardour/editor_ops.cc	2015-05-02 14:23:30 +0000
@@ -4772,12 +4772,17 @@
 		MidiRegionView* const mrv = dynamic_cast<MidiRegionView*>(*r);
 
 		if (mrv) {
-			boost::shared_ptr<Playlist> playlist = mrv->region()->playlist();
-			boost::shared_ptr<MidiRegion> newregion = mrv->midi_region()->clone ();
-
-			playlist->clear_changes ();
-			playlist->replace_region (mrv->region(), newregion, mrv->region()->position());
-			_session->add_command(new StatefulDiffCommand (playlist));
+			try {
+				boost::shared_ptr<Playlist> playlist = mrv->region()->playlist();
+				boost::shared_ptr<MidiSource> new_source = _session->create_midi_source_by_stealing_name (mrv->midi_view()->track());
+				boost::shared_ptr<MidiRegion> newregion = mrv->midi_region()->clone (new_source);
+				
+				playlist->clear_changes ();
+				playlist->replace_region (mrv->region(), newregion, mrv->region()->position());
+				_session->add_command(new StatefulDiffCommand (playlist));
+			} catch (...) {
+				error << string_compose (_("Could not unlink %1"), mrv->region()->name()) << endmsg;
+			}
 		}
 
 		r = tmp;
 
=== modified file 'gtk2_ardour/editor_regions.cc'
--- gtk2_ardour/editor_regions.cc	2013-12-23 22:07:52 +0000
+++ gtk2_ardour/editor_regions.cc	2015-05-02 14:23:30 +0000
@@ -114,7 +114,7 @@
 		{ 3, _("Length"),  _("Length of the region") },
 		{ 4, _("Sync"),  _("Position of region sync point, relative to start of the region") },
 		{ 5, _("Fade In"),  _("Length of region fade-in (units: secondary clock), () if disabled") },
-		{ 6, _("Fade Out"),  _("Length of region fade-out (units: secondary clock), () if dsisabled") },
+		{ 6, _("Fade Out"),  _("Length of region fade-out (units: secondary clock), () if disabled") },
 		{ 7, _("L"),  _("Region position locked?") },
 		{ 8, _("G"),  _("Region position glued to Bars|Beats time?") },
 		{ 9, _("M"),  _("Region muted?") },
 
=== modified file 'gtk2_ardour/editor_rulers.cc'
--- gtk2_ardour/editor_rulers.cc	2013-09-21 19:05:02 +0000
+++ gtk2_ardour/editor_rulers.cc	2015-05-02 14:23:30 +0000
@@ -1862,13 +1862,13 @@
 	long millisecs;
 
 	left = sample;
-	hrs = left / (sample_rate * 60 * 60);
-	left -= hrs * sample_rate * 60 * 60;
-	mins = left / (sample_rate * 60);
-	left -= mins * sample_rate * 60;
-	secs = left / sample_rate;
-	left -= secs * sample_rate;
-	millisecs = left * 1000 / sample_rate;
+	hrs = left / (sample_rate * 60 * 60 * 1000);
+	left -= hrs * sample_rate * 60 * 60 * 1000;
+	mins = left / (sample_rate * 60 * 1000);
+	left -= mins * sample_rate * 60 * 1000;
+	secs = left / (sample_rate * 1000);
+	left -= secs * sample_rate * 1000;
+	millisecs = left / sample_rate;
 
 	*millisecs_p = millisecs;
 	*secs_p = secs;
@@ -1888,7 +1888,7 @@
 		return;
 	}
 
-	fr = _session->frame_rate();
+	fr = _session->frame_rate() * 1000;
 
 	/* to prevent 'flashing' */
 	if (lower > (spacer = (framepos_t)(128 * Editor::get_current_zoom ()))) {
@@ -1897,7 +1897,7 @@
 		lower = 0;
 	}
 	upper += spacer;
-	framecnt_t const range = upper - lower;
+	framecnt_t const range = (upper - lower) * 1000;
 
 	if (range <  (fr / 50)) {
 		minsec_mark_interval =  fr / 1000; /* show 1/1000 seconds */
@@ -1997,7 +1997,7 @@
 	}
 
 	*marks = (GtkCustomRulerMark *) g_malloc (sizeof(GtkCustomRulerMark) * minsec_nmarks);
-	pos = ((((framepos_t) floor(lower)) + (minsec_mark_interval/2))/minsec_mark_interval) * minsec_mark_interval;
+	pos = (((1000 * (framepos_t) floor(lower)) + (minsec_mark_interval/2))/minsec_mark_interval) * minsec_mark_interval;
 	switch (minsec_ruler_scale) {
 	case minsec_show_seconds:
 		for (n = 0; n < minsec_nmarks; pos += minsec_mark_interval, ++n) {
@@ -2014,7 +2014,7 @@
 	                        (*marks)[n].style = GtkCustomRulerMarkMicro;
         	        }
                 	(*marks)[n].label = g_strdup (buf);
-              		(*marks)[n].position = pos;
+			(*marks)[n].position = pos/1000.0;
 		}
 	  break;
 	case minsec_show_minutes:
@@ -2032,7 +2032,7 @@
                                 (*marks)[n].style = GtkCustomRulerMarkMicro;
                         }
                         (*marks)[n].label = g_strdup (buf);
-                        (*marks)[n].position = pos;
+                        (*marks)[n].position = pos/1000.0;
                 }
 	  break;
 	case minsec_show_hours:
@@ -2046,14 +2046,14 @@
                                 (*marks)[n].style = GtkCustomRulerMarkMicro;
                         }
                         (*marks)[n].label = g_strdup (buf);
-                        (*marks)[n].position = pos;
+                        (*marks)[n].position = pos/1000.0;
                 }
 	      break;
 	case minsec_show_frames:
 		for (n = 0; n < minsec_nmarks; pos += minsec_mark_interval, ++n) {
 			sample_to_clock_parts (pos, _session->frame_rate(), &hrs, &mins, &secs, &millisecs);
 			if (millisecs % minsec_mark_modulo == 0) {
-				if (secs == 0) {
+				if (millisecs == 0) {
 					(*marks)[n].style = GtkCustomRulerMarkMajor;
 				} else {
 					(*marks)[n].style = GtkCustomRulerMarkMinor;
@@ -2064,7 +2064,7 @@
 				(*marks)[n].style = GtkCustomRulerMarkMicro;
 			}
 			(*marks)[n].label = g_strdup (buf);
-			(*marks)[n].position = pos;
+			(*marks)[n].position = pos/1000.0;
 		}
 	  break;
 	}
 
=== modified file 'gtk2_ardour/ergonomic-us.bindings.in'
--- gtk2_ardour/ergonomic-us.bindings.in	2013-09-21 19:05:02 +0000
+++ gtk2_ardour/ergonomic-us.bindings.in	2015-05-02 14:23:30 +0000
@@ -163,6 +163,7 @@
 ; (gtk_accel_path "<Actions>/Snap/snap-to-eighths" "")
 (gtk_accel_path "<Actions>/Editor/select-all-after-playhead" "<@TERTIARY@><@PRIMARY@>p")
 (gtk_accel_path "<Actions>/Common/ToggleMaximalEditor" "F11")
+(gtk_accel_path "<Actions>/Common/ToggleMaximalMixer" "F12")
 ; (gtk_accel_path "<Actions>/RegionList/SortBySourceFileLength" "")
 ; (gtk_accel_path "<Actions>/Editor/Timecode" "")
 ; (gtk_accel_path "<Actions>/Transport/PlaySelection" "")
 
=== modified file 'gtk2_ardour/gain_meter.cc'
--- gtk2_ardour/gain_meter.cc	2014-01-24 16:31:54 +0000
+++ gtk2_ardour/gain_meter.cc	2015-05-02 14:23:30 +0000
@@ -274,18 +274,24 @@
 GainMeterBase::setup_meters (int len)
 {
 	int meter_width = 5;
+	uint32_t meter_channels = 0;
+	if (_meter) {
+		meter_channels = _meter->input_streams().n_total();
+	} else if (_route) {
+		meter_channels = _route->shared_peak_meter()->input_streams().n_total();
+	}
 
 	switch (_width) {
 		case Wide:
 			//meter_ticks1_area.show();
 			//meter_ticks2_area.show();
 			meter_metric_area.show();
-			if (_route && _route->shared_peak_meter()->input_streams().n_total() == 1) {
+			if (meter_channels == 1) {
 				meter_width = 10;
 			}
 			break;
 		case Narrow:
-			if (_route && _route->shared_peak_meter()->input_streams().n_total() > 1) {
+			if (meter_channels > 1) {
 				meter_width = 4;
 			}
 			//meter_ticks1_area.hide();
 
=== modified file 'gtk2_ardour/level_meter.cc'
--- gtk2_ardour/level_meter.cc	2013-12-23 22:07:52 +0000
+++ gtk2_ardour/level_meter.cc	2015-05-02 14:23:30 +0000
@@ -78,6 +78,7 @@
 	_meter_type_connection.disconnect();
 
 	_meter = meter;
+	color_changed = true;
 
 	if (_meter) {
 		_meter->ConfigurationChanged.connect (_configuration_connection, parent_invalidator, boost::bind (&LevelMeterBase::configuration_changed, this, _1, _2), gui_context());
 
=== modified file 'gtk2_ardour/midi_time_axis.cc'
--- gtk2_ardour/midi_time_axis.cc	2014-01-24 16:31:54 +0000
+++ gtk2_ardour/midi_time_axis.cc	2015-05-02 14:23:30 +0000
@@ -757,7 +757,7 @@
 			Evoral::Parameter fully_qualified_param (MidiCCAutomation, chn, ctl);
 			ctl_items.push_back (
 				CheckMenuElem (
-					string_compose ("<b>%1</b>: %2 [%3]", ctl, name, int (chn)),
+					string_compose ("<b>%1</b>: %2 [%3]", ctl, name, int (chn + 1)),
 					sigc::bind (
 						sigc::mem_fun (*this, &RouteTimeAxisView::toggle_automation_track),
 						fully_qualified_param)));
@@ -1199,16 +1199,56 @@
 void
 MidiTimeAxisView::show_all_automation (bool apply_to_selection)
 {
+	using namespace MIDI::Name;
+
 	if (apply_to_selection) {
 		_editor.get_selection().tracks.foreach_midi_time_axis (
 			boost::bind (&MidiTimeAxisView::show_all_automation, _1, false));
 	} else {
 		if (midi_track()) {
+			// Show existing automation
 			const set<Evoral::Parameter> params = midi_track()->midi_playlist()->contained_automation();
 
 			for (set<Evoral::Parameter>::const_iterator i = params.begin(); i != params.end(); ++i) {
 				create_automation_child(*i, true);
 			}
+
+			// Show automation for all controllers named in midnam file
+			boost::shared_ptr<MasterDeviceNames> device_names = get_device_names();
+			if (gui_property (X_("midnam-model-name")) != "Generic" &&
+			     device_names && !device_names->controls().empty()) {
+				const std::string device_mode       = _midnam_custom_device_mode_selector.get_active_text();
+				const uint16_t    selected_channels = midi_track()->get_playback_channel_mask();
+				for (uint32_t chn = 0; chn < 16; ++chn) {
+					if ((selected_channels & (0x0001 << chn)) == 0) {
+						// Channel not in use
+						continue;
+					}
+
+					boost::shared_ptr<ChannelNameSet> chan_names = device_names->channel_name_set_by_channel(
+						device_mode, chn);
+					if (!chan_names) {
+						continue;
+					}
+
+					boost::shared_ptr<ControlNameList> control_names = device_names->control_name_list(
+						chan_names->control_list_name());
+					if (!control_names) {
+						continue;
+					}
+
+					for (ControlNameList::Controls::const_iterator c = control_names->controls().begin();
+					     c != control_names->controls().end();
+					     ++c) {
+						const uint16_t ctl = c->second->number();
+						if (ctl != MIDI_CTL_MSB_BANK && ctl != MIDI_CTL_LSB_BANK) {
+							/* Skip bank select controllers since they're handled specially */
+							const Evoral::Parameter param(MidiCCAutomation, chn, ctl);
+							create_automation_child(param, true);
+						}
+					}
+				}
+			}
 		}
 
 		RouteTimeAxisView::show_all_automation ();
@@ -1524,8 +1564,7 @@
 
 	real_editor->snap_to (pos, 0);
 
-	boost::shared_ptr<Source> src = _session->create_midi_source_for_session (
-		view()->trackview().track().get(), view()->trackview().track()->name());
+	boost::shared_ptr<Source> src = _session->create_midi_source_by_stealing_name (view()->trackview().track());
 	PropertyList plist;
 
 	plist.add (ARDOUR::Properties::start, 0);
 
=== modified file 'gtk2_ardour/mixer_strip.cc'
--- gtk2_ardour/mixer_strip.cc	2014-01-24 16:31:54 +0000
+++ gtk2_ardour/mixer_strip.cc	2015-05-02 14:23:30 +0000
@@ -37,6 +37,7 @@
 #include "ardour/audio_track.h"
 #include "ardour/audioengine.h"
 #include "ardour/internal_send.h"
+#include "ardour/meter.h"
 #include "ardour/midi_track.h"
 #include "ardour/pannable.h"
 #include "ardour/panner.h"
@@ -1023,32 +1024,62 @@
 	p->automation_state_changed.connect (panstate_connection, invalidator (*this), boost::bind (&PannerUI::pan_automation_state_changed, &panners), gui_context());
 	p->automation_style_changed.connect (panstyle_connection, invalidator (*this), boost::bind (&PannerUI::pan_automation_style_changed, &panners), gui_context());
 
-	/* This call reduncant, PannerUI::set_panner() connects to _panshell->Changed itself
-	 * However, that only works a panner was previously set.
-	 *
-	 * PannerUI must remain subscribed to _panshell->Changed() in case
-	 * we switch the panner eg. AUX-Send and back
-	 * _route->panner_shell()->Changed() vs _panshell->Changed
-	 */
-	if (panners._panner == 0) {
-		panners.panshell_changed ();
-	}
-}
-
-void
-MixerStrip::update_panner_choices ()
-{
-	ENSURE_GUI_THREAD (*this, &MixerStrip::update_panner_choices)
-	if (!_route->panner_shell()) { return; }
-
-	uint32_t in = _route->output()->n_ports().n_audio();
-	uint32_t out = in;
-	if (_route->panner()) {
-		in = _route->panner()->in().n_audio();
-	}
-
-	panners.set_available_panners(PannerManager::instance().PannerManager::get_available_panners(in, out));
-}
+<<<<<<< TREE
+	/* This call reduncant, PannerUI::set_panner() connects to _panshell->Changed itself
+	 * However, that only works a panner was previously set.
+	 *
+	 * PannerUI must remain subscribed to _panshell->Changed() in case
+	 * we switch the panner eg. AUX-Send and back
+	 * _route->panner_shell()->Changed() vs _panshell->Changed
+	 */
+	if (panners._panner == 0) {
+		panners.panshell_changed ();
+	}
+}
+
+void
+MixerStrip::update_panner_choices ()
+{
+	ENSURE_GUI_THREAD (*this, &MixerStrip::update_panner_choices)
+	if (!_route->panner_shell()) { return; }
+
+	uint32_t in = _route->output()->n_ports().n_audio();
+	uint32_t out = in;
+	if (_route->panner()) {
+		in = _route->panner()->in().n_audio();
+	}
+
+	panners.set_available_panners(PannerManager::instance().PannerManager::get_available_panners(in, out));
+}
+=======
+	/* This call reduncant, PannerUI::set_panner() connects to _panshell->Changed itself
+	 * However, that only works a panner was previously set.
+	 *
+	 * PannerUI must remain subscribed to _panshell->Changed() in case
+	 * we switch the panner eg. AUX-Send and back
+	 * _route->panner_shell()->Changed() vs _panshell->Changed
+	 */
+	if (panners._panner == 0) {
+		panners.panshell_changed ();
+	}
+	update_panner_choices();
+}
+
+void
+MixerStrip::update_panner_choices ()
+{
+	ENSURE_GUI_THREAD (*this, &MixerStrip::update_panner_choices)
+	if (!_route->panner_shell()) { return; }
+
+	uint32_t in = _route->output()->n_ports().n_audio();
+	uint32_t out = in;
+	if (_route->panner()) {
+		in = _route->panner()->in().n_audio();
+	}
+
+	panners.set_available_panners(PannerManager::instance().PannerManager::get_available_panners(in, out));
+}
+>>>>>>> MERGE-SOURCE
 
 /*
  * Output port labelling
@@ -1869,6 +1900,7 @@
 
 	set_current_delivery (send);
 
+	send->meter()->set_type(_route->shared_peak_meter()->get_type());
 	send->set_metering (true);
 	_current_delivery->DropReferences.connect (send_gone_connection, invalidator (*this), boost::bind (&MixerStrip::revert_to_default_display, this), gui_context());
 
@@ -2159,8 +2191,8 @@
 
 	_suspend_menu_callbacks = true;
 	add_level_meter_item_point (items, group, _("Input"), MeterInput);
-	add_level_meter_item_point (items, group, _("Pre-fader"), MeterPreFader);
-	add_level_meter_item_point (items, group, _("Post-fader"), MeterPostFader);
+	add_level_meter_item_point (items, group, _("Pre Fader"), MeterPreFader);
+	add_level_meter_item_point (items, group, _("Post Fader"), MeterPostFader);
 	add_level_meter_item_point (items, group, _("Output"), MeterOutput);
 	add_level_meter_item_point (items, group, _("Custom"), MeterCustom);
 
 
=== modified file 'gtk2_ardour/mixer_ui.cc'
--- gtk2_ardour/mixer_ui.cc	2013-11-06 13:22:44 +0000
+++ gtk2_ardour/mixer_ui.cc	2015-05-02 14:23:30 +0000
@@ -240,6 +240,7 @@
 	group_display.show();
 
 	_in_group_rebuild_or_clear = false;
+	_maximised = false;
 
 	MixerStrip::CatchDeletion.connect (*this, invalidator (*this), boost::bind (&Mixer_UI::remove_strip, this, _1), gui_context());
 
@@ -1559,6 +1560,19 @@
 		}
 	}
 
+	if ((prop = node.property ("maximised"))) {
+		bool yn = string_is_affirmative (prop->value());
+		Glib::RefPtr<Action> act = ActionManager::get_action (X_("Common"), X_("ToggleMaximalMixer"));
+		assert (act);
+		Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
+		bool fs = tact && tact->get_active();
+		if (yn ^ fs) {
+			ActionManager::do_action ("Common",
+					"ToggleMaximalMixer");
+		}
+	}
+
+
 	return 0;
 }
 
@@ -1601,6 +1615,8 @@
 
 	node->add_property ("show-mixer", _visible ? "yes" : "no");
 
+	node->add_property ("maximised", _maximised ? "yes" : "no");
+
 	return *node;
 }
 
@@ -1942,3 +1958,26 @@
 	_session->set_exclusive_input_active (rl, onoff, flip_others);
 }
 
+void
+Mixer_UI::maximise_mixer_space ()
+{
+	if (_maximised) {
+		return;
+	}
+
+	fullscreen ();
+
+	_maximised = true;
+}
+
+void
+Mixer_UI::restore_mixer_space ()
+{
+	if (!_maximised) {
+		return;
+	}
+
+	unfullscreen();
+
+	_maximised = false;
+}
 
=== modified file 'gtk2_ardour/mixer_ui.h'
--- gtk2_ardour/mixer_ui.h	2013-11-06 13:22:44 +0000
+++ gtk2_ardour/mixer_ui.h	2015-05-02 14:23:30 +0000
@@ -80,6 +80,9 @@
 	void show_strip (MixerStrip *);
 	void hide_strip (MixerStrip *);
 
+	void maximise_mixer_space();
+	void restore_mixer_space();
+
 	void ensure_float (Gtk::Window&);
 
         MonitorSection* monitor_section() const { return _monitor_section; }
@@ -279,6 +282,9 @@
 	bool _following_editor_selection;
 
 	void monitor_section_going_away ();
+
+	/// true if we are in fullscreen mode
+	bool _maximised;
 };
 
 #endif /* __ardour_mixer_ui_h__ */
 
=== modified file 'gtk2_ardour/mnemonic-us.bindings.in'
--- gtk2_ardour/mnemonic-us.bindings.in	2013-09-21 19:05:02 +0000
+++ gtk2_ardour/mnemonic-us.bindings.in	2015-05-02 14:23:30 +0000
@@ -189,6 +189,7 @@
 @trans|Editor/toggle-follow-playhead|<@PRIMARY@>f|toggle playhead tracking
 @trans|Transport/ToggleFollowEdits|<@TERTIARY@>f|toggle playhead follows edits
 @wvis|Common/ToggleMaximalEditor|<@PRIMARY@><@SECONDARY@>f|maximise editor space
+@wvis|Common/ToggleMaximalMixer|F12|maximise mixer space
 @wvis|Region/show-rhythm-ferret|<@WINDOW@>f|show rhythm ferret window 
 @mmode|MouseMode/set-mouse-mode-gain|g|region gain mode
 @epp|Region/play-selected-regions|h|play selected region(s)
@@ -338,7 +339,7 @@
 @trans|Transport/ToggleAutoPlay|5|toggle auto play
 @trans|Transport/ToggleAutoReturn|6|toggle auto return
 @trans|Transport/ToggleClick|7|toggle click (metronome)
-@ranges|Editor/set-tempo-from-region|9|set tempo (1 bar) from region(s)
+@ranges|Region/set-tempo-from-region|9|set tempo (1 bar) from region(s)
 @ranges|Editor/set-tempo-from-edit-range|0|set tempo (1 bar) from edit range
 
 ; mouse stuff
 
=== modified file 'gtk2_ardour/opts.cc'
--- gtk2_ardour/opts.cc	2013-10-17 11:16:21 +0000
+++ gtk2_ardour/opts.cc	2015-05-02 14:23:30 +0000
@@ -102,7 +102,7 @@
 		{ "help", 0, 0, 'h' },
 		{ "no-announcements", 0, 0, 'a' },
 		{ "bindings", 0, 0, 'b' },
-		{ "disable-plugins", 1, 0, 'd' },
+		{ "disable-plugins", 0, 0, 'd' },
 		{ "debug", 1, 0, 'D' },
 		{ "no-splash", 0, 0, 'n' },
 		{ "menus", 1, 0, 'm' },
 
=== modified file 'gtk2_ardour/panner_ui.cc'
--- gtk2_ardour/panner_ui.cc	2014-01-24 16:31:54 +0000
+++ gtk2_ardour/panner_ui.cc	2015-05-02 14:23:30 +0000
@@ -49,6 +49,7 @@
 PannerUI::PannerUI (Session* s)
 	: _current_nouts (-1)
 	, _current_nins (-1)
+	, _current_uri ("")
 	, pan_automation_style_button ("")
 	, pan_automation_state_button ("")
 	, _panner_list()
@@ -214,12 +215,17 @@
 	int const nouts = _panner ? _panner->out().n_audio() : -1;
 	int const nins = _panner ? _panner->in().n_audio() : -1;
 
-	if (nouts == _current_nouts && nins == _current_nins) {
+	if (nouts == _current_nouts
+			&& nins == _current_nins
+			&& _current_uri == _panshell->panner_gui_uri()
+			)
+	{
 		return;
 	}
 
         _current_nins = nins;
         _current_nouts = nouts;
+        _current_uri = _panshell->panner_gui_uri();
 
         container_clear (pan_vbox);
 
@@ -236,6 +242,7 @@
 		return;
 	}
 
+<<<<<<< TREE
 	if (_panshell->panner_gui_uri() == "http://ardour.org/plugin/panner_2in2out#ui")
 	{
 		delete big_window;
@@ -286,6 +293,58 @@
 	}
 	else if (_panshell->panner_gui_uri() == "http://ardour.org/plugin/panner_vbap#ui")
 	{
+=======
+	if (_current_uri == "http://ardour.org/plugin/panner_2in2out#ui")
+	{
+		delete big_window;
+		big_window = 0;
+
+		boost::shared_ptr<Pannable> pannable = _panner->pannable();
+
+		_stereo_panner = new StereoPanner (_panshell);
+		_stereo_panner->set_size_request (-1, pan_bar_height);
+		pan_vbox.pack_start (*_stereo_panner, false, false);
+
+		boost::shared_ptr<AutomationControl> ac;
+
+		ac = pannable->pan_azimuth_control;
+		_stereo_panner->StartPositionGesture.connect (sigc::bind (sigc::mem_fun (*this, &PannerUI::start_touch),
+					boost::weak_ptr<AutomationControl> (ac)));
+		_stereo_panner->StopPositionGesture.connect (sigc::bind (sigc::mem_fun (*this, &PannerUI::stop_touch),
+					boost::weak_ptr<AutomationControl>(ac)));
+
+		ac = pannable->pan_width_control;
+		_stereo_panner->StartWidthGesture.connect (sigc::bind (sigc::mem_fun (*this, &PannerUI::start_touch),
+					boost::weak_ptr<AutomationControl> (ac)));
+		_stereo_panner->StopWidthGesture.connect (sigc::bind (sigc::mem_fun (*this, &PannerUI::stop_touch),
+					boost::weak_ptr<AutomationControl>(ac)));
+		_stereo_panner->signal_button_release_event().connect (sigc::mem_fun(*this, &PannerUI::pan_button_event));
+	}
+	else if (_current_uri == "http://ardour.org/plugin/panner_1in2out#ui"
+			|| _current_uri == "http://ardour.org/plugin/panner_balance#ui")
+	{
+		delete big_window;
+		big_window = 0;
+		boost::shared_ptr<Pannable> pannable = _panner->pannable();
+		boost::shared_ptr<AutomationControl> ac = pannable->pan_azimuth_control;
+
+		_mono_panner = new MonoPanner (_panshell);
+
+		_mono_panner->StartGesture.connect (sigc::bind (sigc::mem_fun (*this, &PannerUI::start_touch),
+					boost::weak_ptr<AutomationControl> (ac)));
+		_mono_panner->StopGesture.connect (sigc::bind (sigc::mem_fun (*this, &PannerUI::stop_touch),
+					boost::weak_ptr<AutomationControl>(ac)));
+
+		_mono_panner->signal_button_release_event().connect (sigc::mem_fun(*this, &PannerUI::pan_button_event));
+
+		_mono_panner->set_size_request (-1, pan_bar_height);
+
+		update_pan_sensitive ();
+		pan_vbox.pack_start (*_mono_panner, false, false);
+	}
+	else if (_current_uri == "http://ardour.org/plugin/panner_vbap#ui")
+	{
+>>>>>>> MERGE-SOURCE
 		if (!twod_panner) {
 			twod_panner = new Panner2d (_panshell, 61);
 			twod_panner->set_name ("MixerPanZone");
@@ -383,6 +442,7 @@
 	bypass_menu_item->set_active (_panshell->bypassed());
 	bypass_menu_item->signal_toggled().connect (sigc::mem_fun(*this, &PannerUI::pan_bypass_toggle));
 
+<<<<<<< TREE
 	if (!_panshell->bypassed()) {
 		items.push_back (MenuElem (_("Reset"), sigc::mem_fun (*this, &PannerUI::pan_reset)));
 		items.push_back (MenuElem (_("Edit..."), sigc::mem_fun (*this, &PannerUI::pan_edit)));
@@ -404,6 +464,26 @@
 		}
 		_suspend_menu_callbacks = false;
 	}
+=======
+	if (!_panshell->bypassed()) {
+		items.push_back (MenuElem (_("Reset"), sigc::mem_fun (*this, &PannerUI::pan_reset)));
+		items.push_back (MenuElem (_("Edit..."), sigc::mem_fun (*this, &PannerUI::pan_edit)));
+	}
+
+	if (_panner_list.size() > 1 && !_panshell->bypassed()) {
+		RadioMenuItem::Group group;
+		items.push_back (SeparatorElem());
+
+		_suspend_menu_callbacks = true;
+		for (std::map<std::string,std::string>::const_iterator p = _panner_list.begin(); p != _panner_list.end(); ++p) {
+			items.push_back (RadioMenuElem (group, p->second,
+						sigc::bind(sigc::mem_fun (*this, &PannerUI::pan_set_custom_type), p->first)));
+			RadioMenuItem* i = dynamic_cast<RadioMenuItem *> (&items.back ());
+			i->set_active (_panshell->current_panner_uri() == p->first);
+		}
+		_suspend_menu_callbacks = false;
+	}
+>>>>>>> MERGE-SOURCE
 }
 
 void
 
=== modified file 'gtk2_ardour/panner_ui.h'
--- gtk2_ardour/panner_ui.h	2014-01-24 16:31:54 +0000
+++ gtk2_ardour/panner_ui.h	2015-05-02 14:23:30 +0000
@@ -96,6 +96,7 @@
 	bool in_pan_update;
 	int _current_nouts;
 	int _current_nins;
+	std::string _current_uri;
 
 	static const int pan_bar_height;
 
 
=== modified file 'gtk2_ardour/plugin_ui.cc'
--- gtk2_ardour/plugin_ui.cc	2013-10-17 11:16:21 +0000
+++ gtk2_ardour/plugin_ui.cc	2015-05-02 14:23:30 +0000
@@ -161,7 +161,9 @@
 
 PluginUIWindow::~PluginUIWindow ()
 {
+#ifndef NDEBUG
 	cerr << "PluginWindow deleted for " << this << endl;
+#endif
 	delete _pluginui;
 }
 
 
=== modified file 'gtk2_ardour/processor_box.cc'
--- gtk2_ardour/processor_box.cc	2014-01-24 16:31:54 +0000
+++ gtk2_ardour/processor_box.cc	2015-05-02 14:23:30 +0000
@@ -820,6 +820,7 @@
 	Gdk::Color const fg = get_style()->get_fg (STATE_NORMAL);
 	cairo_set_source_rgb (cr, fg.get_red_p (), fg.get_green_p (), fg.get_blue_p ());
 
+<<<<<<< TREE
 	const uint32_t sources = _sources.n_total();
 	const uint32_t sinks = _sinks.n_total();
 
@@ -878,6 +879,75 @@
 		cairo_stroke (cr);
 	}
 	cairo_destroy(cr);
+=======
+	const uint32_t sources = _sources.n_total();
+	const uint32_t sinks = _sinks.n_total();
+
+	/* MIDI */
+	const uint32_t midi_sources = _sources.n_midi();
+	const uint32_t midi_sinks = _sinks.n_midi();
+
+	cairo_set_source_rgb (cr,
+			UINT_RGBA_R_FLT(midi_port_color),
+			UINT_RGBA_G_FLT(midi_port_color),
+			UINT_RGBA_B_FLT(midi_port_color));
+	if (midi_sources > 0 && midi_sinks > 0 && sinks > 1 && sources > 1) {
+		for (uint32_t i = 0 ; i < midi_sources; ++i) {
+			const float si_x  = rintf(width * (.2f + .6f * i  / (sinks - 1.f))) + .5f;
+			const float si_x0 = rintf(width * (.2f + .6f * i / (sources - 1.f))) + .5f;
+			cairo_move_to (cr, si_x, height);
+			cairo_curve_to (cr, si_x, 0, si_x0, height, si_x0, 0);
+			cairo_stroke (cr);
+		}
+	} else if (midi_sources == 1 && midi_sinks == 1 && sinks == 1 && sources == 1) {
+		const float si_x = rintf(width * .5f) + .5f;
+		cairo_move_to (cr, si_x, height);
+		cairo_line_to (cr, si_x, 0);
+		cairo_stroke (cr);
+	} else if (midi_sources == 1 && midi_sinks == 1) {
+		/* unusual cases -- removed synth, midi-track w/audio plugins */
+		const float si_x  = rintf(width * (sinks   > 1 ? .2f : .5f)) + .5f;
+		const float si_x0 = rintf(width * (sources > 1 ? .2f : .5f)) + .5f;
+		cairo_move_to (cr, si_x, height);
+		cairo_curve_to (cr, si_x, 0, si_x0, height, si_x0, 0);
+		cairo_stroke (cr);
+	}
+
+	/* AUDIO */
+	const uint32_t audio_sources = _sources.n_audio();
+	const uint32_t audio_sinks = _sinks.n_audio();
+	cairo_set_source_rgb (cr,
+			UINT_RGBA_R_FLT(audio_port_color),
+			UINT_RGBA_G_FLT(audio_port_color),
+			UINT_RGBA_B_FLT(audio_port_color));
+
+	if (_splitting) {
+		assert(audio_sources < 2);
+		assert(audio_sinks > 1);
+		/* assume there is only ever one MIDI port */
+		const float si_x0 = rintf(width * (midi_sources > 0 ? .8f : .5f)) + .5f;
+		for (uint32_t i = midi_sinks; i < sinks; ++i) {
+			const float si_x = rintf(width * (.2f + .6f * i / (sinks - 1.f))) + .5f;
+			cairo_move_to (cr, si_x, height);
+			cairo_curve_to (cr, si_x, 0, si_x0, height, si_x0, 0);
+			cairo_stroke (cr);
+		}
+	} else if (audio_sources > 1) {
+		for (uint32_t i = 0 ; i < audio_sources; ++i) {
+			const float si_x = rintf(width * (.2f + .6f * (i + midi_sinks) / (sinks - 1.f))) + .5f;
+			const float si_x0 = rintf(width * (.2f + .6f * (i + midi_sources) / (sources - 1.f))) + .5f;
+			cairo_move_to (cr, si_x, height);
+			cairo_curve_to (cr, si_x, 0, si_x0, height, si_x0, 0);
+			cairo_stroke (cr);
+		}
+	} else if (audio_sources == 1 && audio_sinks == 1) {
+		const float si_x = rintf(width * .5f) + .5f;
+		cairo_move_to (cr, si_x, height);
+		cairo_line_to (cr, si_x, 0);
+		cairo_stroke (cr);
+	}
+	cairo_destroy(cr);
+>>>>>>> MERGE-SOURCE
 	return true;
 }
 
 
=== modified file 'gtk2_ardour/route_ui.cc'
--- gtk2_ardour/route_ui.cc	2013-11-06 13:22:44 +0000
+++ gtk2_ardour/route_ui.cc	2015-05-02 14:23:30 +0000
@@ -1237,13 +1237,13 @@
 
 	MenuList& items = mute_menu->items();
 
-	pre_fader_mute_check = manage (new CheckMenuItem(_("Pre Fader")));
+	pre_fader_mute_check = manage (new CheckMenuItem(_("Pre Fader Sends")));
 	init_mute_menu(MuteMaster::PreFader, pre_fader_mute_check);
 	pre_fader_mute_check->signal_toggled().connect(sigc::bind (sigc::mem_fun (*this, &RouteUI::toggle_mute_menu), MuteMaster::PreFader, pre_fader_mute_check));
 	items.push_back (CheckMenuElem(*pre_fader_mute_check));
 	pre_fader_mute_check->show_all();
 
-	post_fader_mute_check = manage (new CheckMenuItem(_("Post Fader")));
+	post_fader_mute_check = manage (new CheckMenuItem(_("Post Fader Sends")));
 	init_mute_menu(MuteMaster::PostFader, post_fader_mute_check);
 	post_fader_mute_check->signal_toggled().connect(sigc::bind (sigc::mem_fun (*this, &RouteUI::toggle_mute_menu), MuteMaster::PostFader, post_fader_mute_check));
 	items.push_back (CheckMenuElem(*post_fader_mute_check));
 
=== modified file 'gtk2_ardour/sfdb_ui.cc'
--- gtk2_ardour/sfdb_ui.cc	2014-01-24 16:31:54 +0000
+++ gtk2_ardour/sfdb_ui.cc	2015-05-02 14:23:30 +0000
@@ -116,7 +116,7 @@
 	return _("as new tracks");
 }
 
-SoundFileBox::SoundFileBox (bool persistent)
+SoundFileBox::SoundFileBox (bool /*persistent*/)
 	: table (6, 2),
 	  length_clock ("sfboxLengthClock", true, "", false, false, true, false),
 	  timecode_clock ("sfboxTimecodeClock", true, "", false, false, false, false),
@@ -279,6 +279,7 @@
 
 	string error_msg;
 
+<<<<<<< TREE
 	if (SMFSource::safe_midi_file_extension (path)) {
 
 		boost::shared_ptr<SMFSource> ms =
@@ -311,6 +312,40 @@
 		return true;
 	}
 
+=======
+	if (SMFSource::valid_midi_file (path)) {
+
+		boost::shared_ptr<SMFSource> ms =
+			boost::dynamic_pointer_cast<SMFSource> (
+					SourceFactory::createExternal (DataType::MIDI, *_session,
+											 path, 0, Source::Flag (0), false));
+
+		preview_label.set_markup (_("<b>Midi File Information</b>"));
+
+		format_text.set_text ("MIDI");
+		samplerate_value.set_text ("-");
+		tags_entry.get_buffer()->set_text ("");
+		timecode_clock.set (0);
+		tags_entry.set_sensitive (false);
+
+		if (ms) {
+			channels_value.set_text (to_string(ms->num_tracks(), std::dec));
+			length_clock.set (ms->length(ms->timeline_position()));
+		} else {
+			channels_value.set_text ("");
+			length_clock.set (0);
+		}
+
+		if (_session && ms) {
+			play_btn.set_sensitive (true);
+		} else {
+			play_btn.set_sensitive (false);
+		}
+
+		return true;
+	}
+
+>>>>>>> MERGE-SOURCE
 	if(!AudioFileSource::get_soundfile_info (filename, sf_info, error_msg)) {
 
 		preview_label.set_markup (_("<b>Sound File Information</b>"));
@@ -403,6 +438,7 @@
 	}
 
 	boost::shared_ptr<Region> r;
+<<<<<<< TREE
 
 	if (SMFSource::safe_midi_file_extension (path)) {
 
@@ -456,6 +492,61 @@
 		AudioSource::set_build_peakfiles (old_sbp);
 
 		if (srclist.empty()) {
+=======
+
+	if (SMFSource::valid_midi_file (path)) {
+
+		boost::shared_ptr<SMFSource> ms =
+			boost::dynamic_pointer_cast<SMFSource> (
+					SourceFactory::createExternal (DataType::MIDI, *_session,
+											 path, 0, Source::Flag (0), false));
+
+		string rname = region_name_from_path (ms->path(), false);
+
+		PropertyList plist;
+
+		plist.add (ARDOUR::Properties::start, 0);
+		plist.add (ARDOUR::Properties::length, ms->length(ms->timeline_position()));
+		plist.add (ARDOUR::Properties::name, rname);
+		plist.add (ARDOUR::Properties::layer, 0);
+
+		r = boost::dynamic_pointer_cast<MidiRegion> (RegionFactory::create (boost::dynamic_pointer_cast<Source>(ms), plist, false));
+		assert(r);
+
+	} else {
+
+		SourceList srclist;
+		boost::shared_ptr<AudioFileSource> afs;
+		bool old_sbp = AudioSource::get_build_peakfiles ();
+
+		/* don't even think of building peakfiles for these files */
+
+		AudioSource::set_build_peakfiles (false);
+
+		for (int n = 0; n < sf_info.channels; ++n) {
+			try {
+				afs = boost::dynamic_pointer_cast<AudioFileSource> (
+					SourceFactory::createExternal (DataType::AUDIO, *_session,
+											 path, n,
+											 Source::Flag (0), false));
+				if (afs->sample_rate() != _session->nominal_frame_rate()) {
+					boost::shared_ptr<SrcFileSource> sfs (new SrcFileSource(*_session, afs, _src_quality));
+					srclist.push_back(sfs);
+				} else {
+					srclist.push_back(afs);
+				}
+
+			} catch (failed_constructor& err) {
+				error << _("Could not access soundfile: ") << path << endmsg;
+				AudioSource::set_build_peakfiles (old_sbp);
+				return;
+			}
+		}
+
+		AudioSource::set_build_peakfiles (old_sbp);
+
+		if (srclist.empty()) {
+>>>>>>> MERGE-SOURCE
 			return;
 		}
 
@@ -1307,7 +1398,7 @@
 
 	/* See if we are thinking about importing any MIDI files */
 	vector<string>::iterator i = paths.begin ();
-	while (i != paths.end() && SMFSource::safe_midi_file_extension (*i) == false) {
+	while (i != paths.end() && SMFSource::valid_midi_file (*i) == false) {
 		++i;
 	}
 	bool const have_a_midi_file = (i != paths.end ());
@@ -1535,7 +1626,7 @@
 				src_needed = true;
 			}
 
-		} else if (SMFSource::safe_midi_file_extension (*i)) {
+		} else if (SMFSource::valid_midi_file (*i)) {
 
 			Evoral::SMF reader;
 			reader.open(*i);
 
=== modified file 'gtk2_ardour/stereo_panner.cc'
--- gtk2_ardour/stereo_panner.cc	2014-01-24 16:31:54 +0000
+++ gtk2_ardour/stereo_panner.cc	2015-05-02 14:23:30 +0000
@@ -83,22 +83,42 @@
 		set_colors ();
 		have_colors = true;
 	}
-	if (!have_font) {
-		Pango::FontDescription font;
-		Pango::AttrFontDesc* font_attr;
-		font = Pango::FontDescription ("ArdourMono");
-		font.set_weight (Pango::WEIGHT_BOLD);
-		font.set_size(9 * PANGO_SCALE);
-		font_attr = new Pango::AttrFontDesc (Pango::Attribute::create_attr_font_desc (font));
-		panner_font_attributes.change(*font_attr);
-		delete font_attr;
-		have_font = true;
-	}
-
-	position_control->Changed.connect (panvalue_connections, invalidator(*this), boost::bind (&StereoPanner::value_change, this), gui_context());
-	width_control->Changed.connect (panvalue_connections, invalidator(*this), boost::bind (&StereoPanner::value_change, this), gui_context());
-
-	_panner_shell->Changed.connect (panshell_connections, invalidator (*this), boost::bind (&StereoPanner::bypass_handler, this), gui_context());
+<<<<<<< TREE
+	if (!have_font) {
+		Pango::FontDescription font;
+		Pango::AttrFontDesc* font_attr;
+		font = Pango::FontDescription ("ArdourMono");
+		font.set_weight (Pango::WEIGHT_BOLD);
+		font.set_size(9 * PANGO_SCALE);
+		font_attr = new Pango::AttrFontDesc (Pango::Attribute::create_attr_font_desc (font));
+		panner_font_attributes.change(*font_attr);
+		delete font_attr;
+		have_font = true;
+	}
+
+	position_control->Changed.connect (panvalue_connections, invalidator(*this), boost::bind (&StereoPanner::value_change, this), gui_context());
+	width_control->Changed.connect (panvalue_connections, invalidator(*this), boost::bind (&StereoPanner::value_change, this), gui_context());
+
+	_panner_shell->Changed.connect (panshell_connections, invalidator (*this), boost::bind (&StereoPanner::bypass_handler, this), gui_context());
+=======
+	if (!have_font) {
+		Pango::FontDescription font;
+		Pango::AttrFontDesc* font_attr;
+		font = Pango::FontDescription ("ArdourMono");
+		font.set_weight (Pango::WEIGHT_BOLD);
+		font.set_size(9 * PANGO_SCALE);
+		font_attr = new Pango::AttrFontDesc (Pango::Attribute::create_attr_font_desc (font));
+		panner_font_attributes.change(*font_attr);
+		delete font_attr;
+		have_font = true;
+	}
+
+	position_control->Changed.connect (panvalue_connections, invalidator(*this), boost::bind (&StereoPanner::value_change, this), gui_context());
+	width_control->Changed.connect (panvalue_connections, invalidator(*this), boost::bind (&StereoPanner::value_change, this), gui_context());
+
+	_panner_shell->Changed.connect (panshell_connections, invalidator (*this), boost::bind (&StereoPanner::bypass_handler, this), gui_context());
+	_panner_shell->PannableChanged.connect (panshell_connections, invalidator (*this), boost::bind (&StereoPanner::pannable_handler, this), gui_context());
+>>>>>>> MERGE-SOURCE
 
 	ColorsChanged.connect (sigc::mem_fun (*this, &StereoPanner::color_handler));
 
 
=== modified file 'gtk2_ardour/transcode_ffmpeg.cc'
--- gtk2_ardour/transcode_ffmpeg.cc	2013-09-21 19:05:02 +0000
+++ gtk2_ardour/transcode_ffmpeg.cc	2015-05-02 14:23:30 +0000
@@ -46,6 +46,7 @@
 	m_avoffset = m_lead_in = m_lead_out = 0;
 	m_width = m_height = 0;
 	m_aspect = m_fps = 0;
+	m_sar = "";
 #if 1 /* tentative debug mode */
 	debug_enable = false;
 #endif
@@ -70,17 +71,19 @@
 	if (ffmpeg_exe.empty() || ffprobe_exe.empty()) {
 		warning << string_compose(
 				_(
-				"No ffprobe or ffmpeg executables could be found on this system.\n"
-				"Video import and export is not possible until you install those tools.\n"
-				"%1 requires ffmpeg and ffprobe from ffmpeg.org - version 1.1 or newer.\n"
-				"\n"
-				"The tools are included with the %1 releases from ardour.org "
-				"and also available with the video-server at http://x42.github.com/harvid/\n"
-				"\n"
-				"Important: the files need to be installed in $PATH and named ffmpeg_harvid and ffprobe_harvid.\n"
-				"If you already have a suitable ffmpeg installation on your system, we recommend creating "
-				"symbolic links from ffmpeg to ffmpeg_harvid and from ffprobe to ffprobe_harvid.\n"
-				), PROGRAM_NAME) << endmsg;
+					"No ffprobe or ffmpeg executables could be found on this system.\n"
+					"Video import and export is not possible until you install those tools.\n"
+					"%1 requires ffmpeg and ffprobe from ffmpeg.org - version 1.1 or newer.\n"
+					"\n"
+					"The tools are included with the %1 releases from ardour.org "
+					"and also available with the video-server at http://x42.github.com/harvid/\n"
+					"\n"
+					"Important: the files need to be installed in $PATH and named ffmpeg_harvid and ffprobe_harvid.\n"
+					"If you already have a suitable ffmpeg installation on your system, we recommend creating "
+					"symbolic links from ffmpeg to ffmpeg_harvid and from ffprobe to ffprobe_harvid.\n"
+					"\n"
+					"see also http://manual.ardour.org/video-timeline/setup/"
+				 ), PROGRAM_NAME) << endmsg;
 		return;
 	}
 	ffexecok = true;
@@ -138,6 +141,7 @@
 	m_width = m_height = 0;
 	m_fps = m_aspect = 0;
 	m_duration = 0;
+	m_sar.clear();
 	m_codec.clear();
 	m_audio.clear();
 
@@ -199,6 +203,13 @@
 						m_duration = atof(value) * m_fps * timebase;
 					} else if (key == X_("duration") && m_fps != 0 && m_duration == 0) {
 						m_duration = atof(value) * m_fps;
+					} else if (key == X_("sample_aspect_ratio")) {
+						std::string::size_type pos;
+						pos = value.find_first_of(':');
+						if (pos != std::string::npos && atof(value.substr(pos+1)) != 0) {
+							m_sar = value;
+							m_sar.replace(pos, 1, "/");
+						}
 					} else if (key == X_("display_aspect_ratio")) {
 						std::string::size_type pos;
 						pos = value.find_first_of(':');
@@ -340,20 +351,28 @@
 	if (m_lead_in != 0 && m_lead_out != 0) {
 		std::ostringstream osstream;
 		argp[a++] = strdup("-vf");
-		osstream << X_("color=c=black:s=") << m_width << X_("x") << m_height << X_(":d=") << m_lead_in << X_(" [pre]; ");
-		osstream << X_("color=c=black:s=") << m_width << X_("x") << m_height << X_(":d=") << m_lead_out << X_(" [post]; ");
+		osstream << X_("color=c=black:s=") << m_width << X_("x") << m_height << X_(":d=") << m_lead_in;
+		if (!m_sar.empty()) osstream << X_(":sar=") << m_sar;
+		osstream << X_(" [pre]; ");
+		osstream << X_("color=c=black:s=") << m_width << X_("x") << m_height << X_(":d=") << m_lead_out;
+		if (!m_sar.empty()) osstream << X_(":sar=") << m_sar;
+		osstream << X_(" [post]; ");
 		osstream << X_("[pre] [in] [post] concat=n=3");
 		argp[a++] = strdup(osstream.str().c_str());
 	} else if (m_lead_in != 0) {
 		std::ostringstream osstream;
 		argp[a++] = strdup("-vf");
-		osstream << X_("color=c=black:s=") << m_width << X_("x") << m_height << X_(":d=") << m_lead_in << X_(" [pre]; ");
+		osstream << X_("color=c=black:s=") << m_width << X_("x") << m_height << X_(":d=") << m_lead_in;
+		if (!m_sar.empty()) osstream << X_(":sar=") << m_sar;
+		osstream << X_(" [pre]; ");
 		osstream << X_("[pre] [in] concat=n=2");
 		argp[a++] = strdup(osstream.str().c_str());
 	} else if (m_lead_out != 0) {
 		std::ostringstream osstream;
 		argp[a++] = strdup("-vf");
-		osstream << X_("color=c=black:s=") << m_width << X_("x") << m_height << X_(":d=") << m_lead_out << X_(" [post]; ");
+		osstream << X_("color=c=black:s=") << m_width << X_("x") << m_height << X_(":d=") << m_lead_out;
+		if (!m_sar.empty()) osstream << X_(":sar=") << m_sar;
+		osstream << X_(" [post]; ");
 		osstream << X_("[in] [post] concat=n=2");
 		argp[a++] = strdup(osstream.str().c_str());
 	}
 
=== modified file 'gtk2_ardour/transcode_ffmpeg.h'
--- gtk2_ardour/transcode_ffmpeg.h	2013-09-21 19:05:02 +0000
+++ gtk2_ardour/transcode_ffmpeg.h	2015-05-02 14:23:30 +0000
@@ -134,6 +134,7 @@
 
 		double m_fps;
 		double m_aspect;
+		std::string m_sar;
 		ARDOUR::framecnt_t m_duration;
 		int m_width;
 		int m_height;
 
=== modified file 'gtk2_ardour/transcode_video_dialog.cc'
--- gtk2_ardour/transcode_video_dialog.cc	2013-10-17 11:16:21 +0000
+++ gtk2_ardour/transcode_video_dialog.cc	2015-05-02 14:23:30 +0000
@@ -177,16 +177,18 @@
 	options_box->pack_start (*l, false, true, 4);
 
 	video_combo.set_name ("PaddedButton");
-	video_combo.append_text(_("Do Not Import Video"));
-	video_combo.append_text(_("Reference From Current Location"));
+	video_combo.append_text(_("Reference From Current Location (Previously Transcoded Files Only)"));
 	if (ffok)  {
 		video_combo.append_text(_("Import/Transcode Video to Session"));
-		video_combo.set_active(2);
-	} else {
 		video_combo.set_active(1);
+	} else {
+		video_combo.set_active(0);
 		video_combo.set_sensitive(false);
 		audio_combo.set_sensitive(false);
 	}
+	if (as.size() > 0) {
+		video_combo.append_text(_("Do Not Import Video (Audio Import Only)"));
+	}
 
 	options_box->pack_start (video_combo, false, false, 4);
 
@@ -225,8 +227,11 @@
 	t->attach (*l, 0, 1, 2, 3);
 	audio_combo.set_name ("PaddedButton");
 	t->attach (audio_combo, 1, 4, 2, 3);
-	audio_combo.append_text("No audio");
-	if (as.size() > 0) {
+	if (as.size() == 0) {
+		audio_combo.append_text(_("No Audio Track Present"));
+		audio_combo.set_sensitive(false);
+	} else {
+		audio_combo.append_text(_("Do Not Extract Audio"));
 		for (TranscodeFfmpeg::FFAudioStreams::iterator it = as.begin(); it < as.end(); ++it) {
 			audio_combo.append_text((*it).name);
 		}
@@ -364,7 +369,7 @@
 void
 TranscodeVideoDialog::launch_transcode ()
 {
-	if (video_combo.get_active_row_number() != 2) {
+	if (video_combo.get_active_row_number() != 1) {
 		launch_audioonly();
 		return;
 	}
@@ -413,8 +418,8 @@
 void
 TranscodeVideoDialog::video_combo_changed ()
 {
-	int i = video_combo.get_active_row_number();
-	if (i != 2) {
+	const int i = video_combo.get_active_row_number();
+	if (i != 1) {
 		scale_combo.set_sensitive(false);
 		aspect_checkbox.set_sensitive(false);
 		height_spinner.set_sensitive(false);
@@ -427,12 +432,19 @@
 		bitrate_checkbox.set_sensitive(true);
 		bitrate_spinner.set_sensitive(true);
 	}
+	if (i == 2 && audio_combo.get_active_row_number() == 0) {
+		audio_combo.set_active(1);
+	}
 }
 
 void
 TranscodeVideoDialog::audio_combo_changed ()
 {
-	;
+	if (video_combo.get_active_row_number() == 2
+			&& audio_combo.get_active_row_number() == 0)
+	{
+		audio_combo.set_active(1);
+	}
 }
 
 void
 
=== modified file 'gtk2_ardour/transcode_video_dialog.h'
--- gtk2_ardour/transcode_video_dialog.h	2013-09-21 19:05:02 +0000
+++ gtk2_ardour/transcode_video_dialog.h	2015-05-02 14:23:30 +0000
@@ -31,9 +31,9 @@
 #include "transcode_ffmpeg.h"
 
 enum VtlTranscodeOption {
- VTL_IMPORT_NO_VIDEO = 0,
- VTL_IMPORT_REFERENCE = 1,
- VTL_IMPORT_TRANSCODED = 2
+ VTL_IMPORT_REFERENCE = 0,
+ VTL_IMPORT_TRANSCODED = 1,
+ VTL_IMPORT_NO_VIDEO = 2
 };
 
 /** @class TranscodeVideoDialog
 
=== modified file 'gtk2_ardour/video_server_dialog.cc'
--- gtk2_ardour/video_server_dialog.cc	2013-10-17 11:16:21 +0000
+++ gtk2_ardour/video_server_dialog.cc	2015-05-02 14:23:30 +0000
@@ -89,8 +89,13 @@
 	else {
 		PBD::warning <<
 			string_compose(
-			_("The external video server 'harvid' can not be found. The tool is included with the %1 releases from ardour.org, "
-			  "alternatively you can download it from http://x42.github.com/harvid/ or acquire it from your distribution."), PROGRAM_NAME)
+					_("The external video server 'harvid' can not be found.\n"
+						"The tool is included with the %1 releases from ardour.org, "
+						"alternatively you can download it from http://x42.github.com/harvid/ "
+						"or acquire it from your distribution.\n"
+						"\n"
+						"see also http://manual.ardour.org/video-timeline/setup/"
+					 ), PROGRAM_NAME)
 			<< endmsg;
 	}
 
 
=== modified file 'gtk2_ardour/video_timeline.cc'
--- gtk2_ardour/video_timeline.cc	2013-09-21 19:05:02 +0000
+++ gtk2_ardour/video_timeline.cc	2015-05-02 14:23:30 +0000
@@ -39,6 +39,10 @@
 #include <pthread.h>
 #include <curl/curl.h>
 
+#ifdef PLATFORM_WINDOWS
+#include <windows.h>
+#endif
+
 #include "i18n.h"
 
 using namespace std;
@@ -718,25 +722,52 @@
 VideoTimeLine::find_xjadeo () {
 	std::string xjadeo_file_path;
 	if (getenv("XJREMOTE")) {
-		_xjadeo_bin = strdup(getenv("XJREMOTE")); // XXX TODO: free it?!
-	} else if (find_file_in_search_path (SearchPath(Glib::getenv("PATH")), X_("xjremote"), xjadeo_file_path)) {
-		_xjadeo_bin = xjadeo_file_path;
+		_xjadeo_bin = getenv("XJREMOTE");
+	}
+	else if (find_file_in_search_path (SearchPath(Glib::getenv("PATH")), X_("xjremote"), xjadeo_file_path)) {
+		_xjadeo_bin = xjadeo_file_path;
+	}
+	else if (find_file_in_search_path (SearchPath(Glib::getenv("PATH")), X_("xjadeo"), xjadeo_file_path)) {
+		_xjadeo_bin = xjadeo_file_path;
+	}
+#ifdef __APPLE__
+	else if (Glib::file_test(X_("/Applications/Xjadeo.app/Contents/MacOS/xjremote"), Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_EXECUTABLE)) {
+		_xjadeo_bin = X_("/Applications/Xjadeo.app/Contents/MacOS/xjremote");
 	}
 	else if (Glib::file_test(X_("/Applications/Jadeo.app/Contents/MacOS/xjremote"), Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_EXECUTABLE)) {
 		_xjadeo_bin = X_("/Applications/Jadeo.app/Contents/MacOS/xjremote");
 	}
-	/* TODO: win32: allow to configure PATH to xjremote */
+#endif
+#ifdef PLATFORM_WINDOWS
+	else {
+		HKEY key;
+		DWORD size = PATH_MAX;
+		char path[PATH_MAX+1];
+		xjadeo_file_path = X_("");
+		if (   (ERROR_SUCCESS == RegOpenKeyExA (HKEY_LOCAL_MACHINE, "Software\\RSS\\xjadeo", 0, KEY_READ, &key))
+		    && (ERROR_SUCCESS == RegQueryValueExA (key, "Install_Dir", 0, NULL, (LPBYTE)path, &size))
+		   )
+		{
+			xjadeo_file_path = g_build_filename(path, X_("xjadeo.exe"));
+		}
+	}
+	if (Glib::file_test(xjadeo_file_path, Glib::FILE_TEST_EXISTS)) {
+		_xjadeo_bin = xjadeo_file_path;
+	}
 	else if (Glib::file_test(X_("C:\\Program Files\\xjadeo\\xjremote.exe"), Glib::FILE_TEST_EXISTS)) {
 		_xjadeo_bin = X_("C:\\Program Files\\xjadeo\\xjremote.exe");
 	}
 	else if (Glib::file_test(X_("C:\\Program Files\\xjadeo\\xjremote.bat"), Glib::FILE_TEST_EXISTS)) {
 		_xjadeo_bin = X_("C:\\Program Files\\xjadeo\\xjremote.bat");
 	}
+#endif
 	else  {
 		_xjadeo_bin = X_("");
 		warning << _("Video-monitor 'xjadeo' was not found. Please install http://xjadeo.sf.net/ "
 				"(a custom path to xjadeo can be specified by setting the XJREMOTE environment variable. "
-				"It should point to an application compatible with xjadeo's remote-control interface 'xjremote').")
+				"It should point to an application compatible with xjadeo's remote-control interface 'xjremote').\n"
+				"\n"
+				"see also http://manual.ardour.org/video-timeline/setup/")
 			<< endmsg;
 	}
 }
 
=== modified file 'libs/ardour/amp.cc'
--- libs/ardour/amp.cc	2013-09-21 19:05:02 +0000
+++ libs/ardour/amp.cc	2015-05-02 14:23:30 +0000
@@ -372,19 +372,9 @@
 }
 
 void
-Amp::set_gain (gain_t val, void *src)
+Amp::set_gain (gain_t val, void *)
 {
-	val = min (val, max_gain_coefficient);
-
-	if (src != _gain_control.get()) {
-		_gain_control->set_value (val);
-		// bit twisty, this will come back and call us again
-		// (this keeps control in sync with reality)
-		return;
-	}
-
-	_gain_control->set_double (val);
-	_session.set_dirty();
+	_gain_control->set_value (val);
 }
 
 XMLNode&
@@ -414,13 +404,8 @@
 void
 Amp::GainControl::set_value (double val)
 {
-	if (val > max_gain_coefficient) {
-		val = max_gain_coefficient;
-	}
-
-	_amp->set_gain (val, this);
-
-	AutomationControl::set_value(val);
+	AutomationControl::set_value (min (val, (double) max_gain_coefficient));
+	_amp->session().set_dirty ();
 }
 
 double
 
=== modified file 'libs/ardour/ardour/audio_buffer.h'
--- libs/ardour/ardour/audio_buffer.h	2014-01-24 16:31:54 +0000
+++ libs/ardour/ardour/audio_buffer.h	2015-05-02 14:23:30 +0000
@@ -62,7 +62,7 @@
 		assert(&src != this);
 		assert(_capacity > 0);
 		assert(src.type() == DataType::AUDIO);
-		assert(len <= _capacity);
+		assert(dst_offset + len <= _capacity);
 		assert( src_offset <= ((framecnt_t) src.capacity()-len));
 		memcpy(_data + dst_offset, ((const AudioBuffer&)src).data() + src_offset, sizeof(Sample) * len);
 		if (dst_offset == 0 && src_offset == 0 && len == _capacity) {
@@ -173,7 +173,6 @@
 	void set_data (Sample* data, size_t size) {
 		assert(!_owns_data); // prevent leaks
 		_capacity = size;
-		_size = size;
 		_data = data;
 		_silent = false;
 		_written = false;
@@ -185,8 +184,6 @@
 	 */
 	void resize (size_t nframes);
 
-	bool empty() const { return _size == 0; }
-
 	const Sample* data (framecnt_t offset = 0) const {
 		assert(offset <= _capacity);
 		return _data + offset;
@@ -198,7 +195,11 @@
 		return _data + offset;
 	}
 
+<<<<<<< TREE
 	bool check_silence (pframes_t, bool, pframes_t&) const;
+=======
+	bool check_silence (pframes_t, pframes_t&) const;
+>>>>>>> MERGE-SOURCE
 
 	void prepare () { _written = false; _silent = false; }
 	bool written() const { return _written; }
 
=== modified file 'libs/ardour/ardour/audio_diskstream.h'
--- libs/ardour/ardour/audio_diskstream.h	2014-01-24 16:31:54 +0000
+++ libs/ardour/ardour/audio_diskstream.h	2015-05-02 14:23:30 +0000
@@ -139,7 +139,6 @@
 	void set_block_size (pframes_t);
 	int  internal_playback_seek (framecnt_t distance);
 	int  can_internal_playback_seek (framecnt_t distance);
-	std::list<boost::shared_ptr<Source> > steal_write_sources();
 	void reset_write_sources (bool, bool force = false);
 	void non_realtime_input_change ();
 	void non_realtime_locate (framepos_t location);
 
=== modified file 'libs/ardour/ardour/audiofilesource.h'
--- libs/ardour/ardour/audiofilesource.h	2013-09-21 19:05:02 +0000
+++ libs/ardour/ardour/audiofilesource.h	2015-05-02 14:23:30 +0000
@@ -39,10 +39,6 @@
 public:
 	virtual ~AudioFileSource ();
 
-	bool set_name (const std::string& newname) {
-		return (set_source_name(newname, destructive()) == 0);
-	}
-
 	std::string peak_path (std::string audio_path);
 	std::string find_broken_peakfile (std::string missing_peak_path,
 	                                  std::string audio_path);
@@ -97,6 +93,12 @@
 	/** Constructor to be called for existing in-session files */
 	AudioFileSource (Session&, const XMLNode&, bool must_exist = true);
 
+	/** Constructor to be called for crash recovery. Final argument is not
+	 * used but exists to differentiate from the external-to-session
+	 * constructor above.
+	 */
+	AudioFileSource (Session&, const std::string& path, Source::Flag flags, bool);
+
 	int init (const std::string& idstr, bool must_exist);
 
 	virtual void set_header_timeline_position () = 0;
 
=== modified file 'libs/ardour/ardour/buffer.h'
--- libs/ardour/ardour/buffer.h	2014-01-24 16:31:54 +0000
+++ libs/ardour/ardour/buffer.h	2015-05-02 14:23:30 +0000
@@ -46,16 +46,9 @@
 	/** Factory function */
 	static Buffer* create(DataType type, size_t capacity);
 
-	/** Maximum capacity of buffer.
-	 * Note in some cases the entire buffer may not contain valid data, use size. */
+	/** Maximum capacity of buffer. */
 	size_t capacity() const { return _capacity; }
 
-	/** Amount of valid data in buffer.  Use this over capacity almost always. */
-	size_t size() const { return _size; }
-
-	/** Return true if the buffer contains no data, false otherwise */
-	virtual bool empty() const { return _size == 0; }
-
 	/** Type of this buffer.
 	 * Based on this you can static cast a Buffer* to the desired type. */
 	DataType type() const { return _type; }
@@ -80,12 +73,11 @@
 
   protected:
 	Buffer(DataType type)
-		: _type(type), _capacity(0), _size(0), _silent (true)
+		: _type(type), _capacity(0), _silent (true)
 	{}
 
 	DataType  _type;
 	pframes_t _capacity;
-	pframes_t _size;
 	bool      _silent;
 };
 
 
=== modified file 'libs/ardour/ardour/diskstream.h'
--- libs/ardour/ardour/diskstream.h	2013-10-17 11:16:21 +0000
+++ libs/ardour/ardour/diskstream.h	2015-05-02 14:23:30 +0000
@@ -70,6 +70,8 @@
 
 	virtual bool set_name (const std::string& str);
 
+	virtual std::string steal_write_source_name () { return std::string(); }
+
 	boost::shared_ptr<ARDOUR::IO> io() const { return _io; }
 	void set_track (ARDOUR::Track *);
 
 
=== modified file 'libs/ardour/ardour/file_source.h'
--- libs/ardour/ardour/file_source.h	2013-09-21 19:05:02 +0000
+++ libs/ardour/ardour/file_source.h	2015-05-02 14:23:30 +0000
@@ -44,7 +44,7 @@
 /** A source associated with a file on disk somewhere */
 class FileSource : virtual public Source {
 public:
-	virtual ~FileSource () {}
+	virtual ~FileSource ();
 
 	virtual const std::string& path() const { return _path; }
 
@@ -74,6 +74,7 @@
 
 	void inc_use_count ();
 	bool removable () const;
+        bool is_stub () const;
 
 	const std::string& origin() const { return _origin; }
 
@@ -81,6 +82,13 @@
 	
 	static PBD::Signal3<int,std::string,std::string,std::vector<std::string> > AmbiguousFileName;
 
+	void existence_check ();
+	virtual void prevent_deletion ();
+
+	/** Rename the file on disk referenced by this source to \param newname
+	 */
+	int rename (const std::string& name);
+
 protected:
 	FileSource (Session& session, DataType type,
 	            const std::string& path,
@@ -102,7 +110,6 @@
 	std::string _origin;
 	bool        _open;
 
-	void prevent_deletion ();
 };
 
 } // namespace ARDOUR
 
=== modified file 'libs/ardour/ardour/midi_buffer.h'
--- libs/ardour/ardour/midi_buffer.h	2013-10-17 11:16:21 +0000
+++ libs/ardour/ardour/midi_buffer.h	2015-05-02 14:23:30 +0000
@@ -48,6 +48,8 @@
 	uint8_t* reserve(TimeType time, size_t size);
 
 	void resize(size_t);
+	size_t size() const { return _size; }
+	bool empty() const { return _size == 0; }
 
 	bool merge_in_place(const MidiBuffer &other);
 
@@ -159,6 +161,7 @@
 	friend class iterator_base< const MidiBuffer, const Evoral::MIDIEvent<TimeType> >;
 
 	uint8_t* _data; ///< timestamp, event, timestamp, event, ...
+	pframes_t _size;
 };
 
 
 
=== modified file 'libs/ardour/ardour/midi_diskstream.h'
--- libs/ardour/ardour/midi_diskstream.h	2014-01-24 16:31:54 +0000
+++ libs/ardour/ardour/midi_diskstream.h	2015-05-02 14:23:30 +0000
@@ -111,7 +111,7 @@
 	void set_block_size (pframes_t);
 	int  internal_playback_seek (framecnt_t distance);
 	int  can_internal_playback_seek (framecnt_t distance);
-	std::list<boost::shared_ptr<Source> > steal_write_sources();
+	std::string steal_write_source_name();
 	void reset_write_sources (bool, bool force = false);
 	void non_realtime_input_change ();
 	void non_realtime_locate (framepos_t location);
 
=== modified file 'libs/ardour/ardour/midi_region.h'
--- libs/ardour/ardour/midi_region.h	2013-09-21 19:05:02 +0000
+++ libs/ardour/ardour/midi_region.h	2015-05-02 14:23:30 +0000
@@ -63,6 +63,7 @@
 	~MidiRegion();
 
 	boost::shared_ptr<MidiRegion> clone (std::string path = std::string()) const;
+	boost::shared_ptr<MidiRegion> clone (boost::shared_ptr<MidiSource>) const;
 
 	boost::shared_ptr<MidiSource> midi_source (uint32_t n=0) const;
 
 
=== modified file 'libs/ardour/ardour/midi_source.h'
--- libs/ardour/ardour/midi_source.h	2013-09-21 19:05:02 +0000
+++ libs/ardour/ardour/midi_source.h	2015-05-02 14:23:30 +0000
@@ -48,9 +48,21 @@
 	MidiSource (Session& session, const XMLNode&);
 	virtual ~MidiSource ();
 
-	boost::shared_ptr<MidiSource> clone (const std::string& path,
-					     Evoral::MusicalTime begin = Evoral::MinMusicalTime,
-	                                     Evoral::MusicalTime end = Evoral::MaxMusicalTime);
+	/** Write the data in the given time range to another MidiSource
+	 * \param newsrc MidiSource to which data will be written. Should be a
+	 *        new, empty source. If it already has contents, the results are
+	 *        undefined. Source must be writable.
+	 *
+	 * \param begin time of earliest event that can be written.
+	 * \param end time of latest event that can be written.
+	 *
+	 * Returns zero on success, non-zero if the write failed for any
+	 * reason.
+	 *
+	 */
+	int write_to (boost::shared_ptr<MidiSource> newsrc,
+		      Evoral::MusicalTime begin = Evoral::MinMusicalTime,
+		      Evoral::MusicalTime end = Evoral::MaxMusicalTime);
 
 	/** Read the data in a given time range from the MIDI source.
 	 * All time stamps in parameters are in audio frames (even if the source has tempo time).
 
=== modified file 'libs/ardour/ardour/public_diskstream.h'
--- libs/ardour/ardour/public_diskstream.h	2013-10-17 11:16:21 +0000
+++ libs/ardour/ardour/public_diskstream.h	2015-05-02 14:23:30 +0000
@@ -38,7 +38,7 @@
 	virtual bool destructive () const = 0;
 	virtual std::list<boost::shared_ptr<Source> > & last_capture_sources () = 0;
 	virtual void set_capture_offset () = 0;
-	virtual std::list<boost::shared_ptr<Source> > steal_write_sources () = 0;
+	virtual std::string steal_write_source_name () = 0;
 	virtual void reset_write_sources (bool, bool force = false) = 0;
 	virtual float playback_buffer_load () const = 0;
 	virtual float capture_buffer_load () const = 0;
 
=== modified file 'libs/ardour/ardour/session.h'
--- libs/ardour/ardour/session.h	2014-01-24 16:31:54 +0000
+++ libs/ardour/ardour/session.h	2015-05-02 14:23:30 +0000
@@ -194,13 +194,11 @@
 
 	std::string peak_path (std::string) const;
 
-	std::string change_source_path_by_name (std::string oldpath, std::string oldname, std::string newname, bool destructive);
-
 	std::string peak_path_from_audio_path (std::string) const;
-	std::string new_audio_source_name (const std::string&, uint32_t nchans, uint32_t chan, bool destructive);
-	std::string new_midi_source_name (const std::string&);
-	std::string new_source_path_from_name (DataType type, const std::string&);
+	std::string new_audio_source_path (const std::string&, uint32_t nchans, uint32_t chan, bool destructive, bool take_required);
+	std::string new_midi_source_path (const std::string&);
         RouteList new_route_from_template (uint32_t how_many, const std::string& template_path, const std::string& name);
+	std::vector<std::string> get_paths_for_new_sources (bool allow_replacing, const std::string& import_file_path, uint32_t channels);
 
 	void process (pframes_t nframes);
 
@@ -528,8 +526,6 @@
 
 	boost::shared_ptr<Region> find_whole_file_parent (boost::shared_ptr<Region const>) const;
 
-	std::string path_from_region_name (DataType type, std::string name, std::string identifier);
-
 	boost::shared_ptr<Region>      XMLRegionFactory (const XMLNode&, bool full);
 	boost::shared_ptr<AudioRegion> XMLAudioRegionFactory (const XMLNode&, bool full);
 	boost::shared_ptr<MidiRegion>  XMLMidiRegionFactory (const XMLNode&, bool full);
@@ -582,11 +578,12 @@
 	boost::shared_ptr<AudioFileSource> create_audio_source_for_session (
 		size_t, std::string const &, uint32_t, bool destructive);
 
-	boost::shared_ptr<MidiSource> create_midi_source_for_session (
-		Track*, std::string const &);
+	boost::shared_ptr<MidiSource> create_midi_source_for_session (std::string const &);
+	boost::shared_ptr<MidiSource> create_midi_source_by_stealing_name (boost::shared_ptr<Track>);
 
 	boost::shared_ptr<Source> source_by_id (const PBD::ID&);
-	boost::shared_ptr<Source> source_by_path_and_channel (const std::string&, uint16_t);
+	boost::shared_ptr<AudioFileSource> audio_source_by_path_and_channel (const std::string&, uint16_t) const;
+	boost::shared_ptr<MidiSource> midi_source_by_path (const std::string&) const;
 	uint32_t count_sources_by_origin (const std::string&);
 
 	void add_playlist (boost::shared_ptr<Playlist>, bool unused = false);
@@ -1434,7 +1431,7 @@
 
 	bool no_questions_about_missing_files;
 
-	std::string get_best_session_directory_for_new_source ();
+	std::string get_best_session_directory_for_new_audio ();
 
 	mutable gint _playback_load;
 	mutable gint _capture_load;
 
=== modified file 'libs/ardour/ardour/smf_source.h'
--- libs/ardour/ardour/smf_source.h	2013-09-21 19:05:02 +0000
+++ libs/ardour/ardour/smf_source.h	2015-05-02 14:23:30 +0000
@@ -36,9 +36,11 @@
 /** Standard Midi File (Type 0) Source */
 class SMFSource : public MidiSource, public FileSource, public Evoral::SMF {
 public:
+	/** Constructor for new internal-to-session files */
+	SMFSource (Session& session, const std::string& path, Source::Flag flags);
+
 	/** Constructor for existing external-to-session files */
-	SMFSource (Session& session, const std::string& path,
-			Source::Flag flags = Source::Flag(0));
+	SMFSource (Session& session, const std::string& path);
 
 	/** Constructor for existing in-session files */
 	SMFSource (Session& session, const XMLNode&, bool must_exist = false);
@@ -49,8 +51,6 @@
 		return safe_midi_file_extension(path);
 	}
 
-	bool set_name (const std::string& newname) { return (set_source_name(newname, false) == 0); }
-
 	void append_event_unlocked_beats (const Evoral::Event<Evoral::MusicalTime>& ev);
 	void append_event_unlocked_frames (const Evoral::Event<framepos_t>& ev, framepos_t source_start);
 
@@ -68,6 +68,9 @@
 	void ensure_disk_file ();
 
 	static bool safe_midi_file_extension (const std::string& path);
+	static bool valid_midi_file (const std::string& path);
+
+	void prevent_deletion ();
 
   protected:
 	void set_path (const std::string& newpath);
 
=== modified file 'libs/ardour/ardour/sndfilesource.h'
--- libs/ardour/ardour/sndfilesource.h	2013-09-21 19:05:02 +0000
+++ libs/ardour/ardour/sndfilesource.h	2015-05-02 14:23:30 +0000
@@ -38,7 +38,16 @@
 	               SampleFormat samp_format, HeaderFormat hdr_format, framecnt_t rate,
 	               Flag flags = SndFileSource::default_writable_flags);
 
-	/** Constructor to be called for existing in-session files */
+	/* Constructor to be called for recovering files being used for
+	 * capture. They are in-session, they already exist, they should not
+	 * be writable. They are an odd hybrid (from a constructor point of
+	 * view) of the previous two constructors.
+	 */
+	SndFileSource (Session&, const std::string& path, int chn);
+
+	/** Constructor to be called for existing in-session files during
+	 * session loading 
+	 */
 	SndFileSource (Session&, const XMLNode&);
 
 	~SndFileSource ();
 
=== modified file 'libs/ardour/ardour/source.h'
--- libs/ardour/ardour/source.h	2013-09-21 19:05:02 +0000
+++ libs/ardour/ardour/source.h	2015-05-02 14:23:30 +0000
@@ -47,7 +47,8 @@
 		RemovableIfEmpty = 0x10,
 		RemoveAtDestroy = 0x20,
 		NoPeakFile = 0x40,
-		Destructive = 0x80
+		Destructive = 0x80,
+		Empty = 0x100, /* used for MIDI only */
 	};
 
 	Source (Session&, DataType type, const std::string& name, Flag flags=Flag(0));
 
=== modified file 'libs/ardour/ardour/source_factory.h'
--- libs/ardour/ardour/source_factory.h	2013-09-21 19:05:02 +0000
+++ libs/ardour/ardour/source_factory.h	2015-05-02 14:23:30 +0000
@@ -57,6 +57,9 @@
 		 bool destructive, framecnt_t rate, bool announce = true, bool async = false);
 
 
+	static boost::shared_ptr<Source> createForRecovery
+		(DataType type, Session&, const std::string& path, int chn);
+
 	static boost::shared_ptr<Source> createFromPlaylist
 		(DataType type, Session& s, boost::shared_ptr<Playlist> p, const PBD::ID& orig, const std::string& name,
 		 uint32_t chn, frameoffset_t start, framecnt_t len, bool copy, bool defer_peaks);
 
=== modified file 'libs/ardour/ardour/track.h'
--- libs/ardour/ardour/track.h	2013-10-17 11:16:21 +0000
+++ libs/ardour/ardour/track.h	2015-05-02 14:23:30 +0000
@@ -120,7 +120,7 @@
 	bool destructive () const;
 	std::list<boost::shared_ptr<Source> > & last_capture_sources ();
 	void set_capture_offset ();
-	std::list<boost::shared_ptr<Source> > steal_write_sources();
+	std::string steal_write_source_name ();
 	void reset_write_sources (bool, bool force = false);
 	float playback_buffer_load () const;
 	float capture_buffer_load () const;
 
=== modified file 'libs/ardour/ardour/vestige/aeffectx.h'
--- libs/ardour/ardour/vestige/aeffectx.h	2014-01-24 16:31:54 +0000
+++ libs/ardour/ardour/vestige/aeffectx.h	2015-05-02 14:23:30 +0000
@@ -251,6 +251,7 @@
 
 typedef struct _VstTimeInfo
 {
+<<<<<<< TREE
     /* info from online documentation of VST provided by Steinberg */
 
     double samplePos;
@@ -271,6 +272,26 @@
 } VstTimeInfo;
 
 typedef struct _VstTimeInfo VstTimeInfo;
+=======
+    /* info from online documentation of VST provided by Steinberg */
+
+    double samplePos;
+    double sampleRate;
+    double nanoSeconds;
+    double ppqPos;
+    double tempo;
+    double barStartPos;
+    double cycleStartPos;
+    double cycleEndPos;
+    int32_t   timeSigNumerator;
+    int32_t   timeSigDenominator;
+    int32_t   smpteOffset;
+    int32_t   smpteFrameRate;
+    int32_t   samplesToNextClock;
+    int32_t   flags;
+
+} VstTimeInfo;
+>>>>>>> MERGE-SOURCE
 
 typedef intptr_t (* audioMasterCallback) (AEffect *, int32_t, int32_t, intptr_t, void *, float);
 
 
=== modified file 'libs/ardour/audio_buffer.cc'
--- libs/ardour/audio_buffer.cc	2014-01-24 16:31:54 +0000
+++ libs/ardour/audio_buffer.cc	2015-05-02 14:23:30 +0000
@@ -57,12 +57,6 @@
 
 	if (_data && size < _capacity) {
 		/* buffer is already large enough */
-		
-		if (size < _size) {
-			/* truncate */
-			_size = size;
-		}
-
 		return;
 	}
 
@@ -71,14 +65,17 @@
 	cache_aligned_malloc ((void**) &_data, sizeof (Sample) * size);
 
 	_capacity = size;
-	_size = 0;
 	_silent = false;
 }
 
 bool
 AudioBuffer::check_silence (pframes_t nframes, bool wholebuffer, pframes_t& n) const
 {
+<<<<<<< TREE
 	for (n = 0; (wholebuffer || n < _size) &&  n < nframes; ++n) {
+=======
+	for (n = 0; n < nframes; ++n) {
+>>>>>>> MERGE-SOURCE
 		if (_data[n] != Sample (0)) {
 			return false;
 		}
 
=== modified file 'libs/ardour/audio_diskstream.cc'
--- libs/ardour/audio_diskstream.cc	2013-10-17 11:16:21 +0000
+++ libs/ardour/audio_diskstream.cc	2015-05-02 14:23:30 +0000
@@ -1928,14 +1928,6 @@
 	return 0;
 }
 
-list<boost::shared_ptr<Source> >
-AudioDiskstream::steal_write_sources()
-{
-	/* not possible to steal audio write sources */
-	list<boost::shared_ptr<Source> > ret;
-	return ret;
-}
-
 void
 AudioDiskstream::reset_write_sources (bool mark_write_complete, bool /*force*/)
 {
@@ -2189,11 +2181,16 @@
 				continue;
 			}
 
+			/* XXX as of June 2014, we always record to mono
+			   files. Since this Source is being created as part of
+			   crash recovery, we know that we need the first
+			   channel (the final argument to the SourceFactory
+			   call below). If we ever support non-mono files for
+			   capture, this will need rethinking.
+			*/
+
 			try {
-				fs = boost::dynamic_pointer_cast<AudioFileSource> (
-					SourceFactory::createWritable (
-						DataType::AUDIO, _session,
-						prop->value(), false, _session.frame_rate()));
+				fs = boost::dynamic_pointer_cast<AudioFileSource> (SourceFactory::createForRecovery (DataType::AUDIO, _session, prop->value(), 0));
 			}
 
 			catch (failed_constructor& err) {
@@ -2224,21 +2221,31 @@
 		return -1;
 	}
 
-	boost::shared_ptr<AudioRegion> region;
-
 	try {
 
+		boost::shared_ptr<AudioRegion> wf_region;
+		boost::shared_ptr<AudioRegion> region;
+		
+		/* First create the whole file region */
+
 		PropertyList plist;
-
+		
 		plist.add (Properties::start, 0);
 		plist.add (Properties::length, first_fs->length (first_fs->timeline_position()));
 		plist.add (Properties::name, region_name_from_path (first_fs->name(), true));
 
+		wf_region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (pending_sources, plist));
+
+		wf_region->set_automatic (true);
+		wf_region->set_whole_file (true);
+		wf_region->special_set_position (position);
+
+		/* Now create a region that isn't the whole file for adding to
+		 * the playlist */
+
 		region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (pending_sources, plist));
-
-		region->set_automatic (true);
-		region->set_whole_file (true);
-		region->special_set_position (0);
+		
+		_playlist->add_region (region, position);
 	}
 
 	catch (failed_constructor& err) {
@@ -2249,7 +2256,6 @@
 		return -1;
 	}
 
-	_playlist->add_region (region, position);
 
 	return 0;
 }
 
=== modified file 'libs/ardour/audiofilesource.cc'
--- libs/ardour/audiofilesource.cc	2013-09-21 19:05:02 +0000
+++ libs/ardour/audiofilesource.cc	2015-05-02 14:23:30 +0000
@@ -36,6 +36,7 @@
 #include "pbd/stl_delete.h"
 #include "pbd/strsplit.h"
 #include "pbd/shortpath.h"
+#include "pbd/stacktrace.h"
 #include "pbd/enumwriter.h"
 
 #include <sndfile.h>
@@ -114,6 +115,22 @@
 	}
 }
 
+/** Constructor used for existing internal-to-session files during crash
+ * recovery. File must exist
+ */
+AudioFileSource::AudioFileSource (Session& s, const string& path, Source::Flag flags, bool /* ignored-exists-for-prototype differentiation */)
+	: Source (s, DataType::AUDIO, path, flags)
+	, AudioSource (s, path)
+	, FileSource (s, DataType::AUDIO, path, string(), flags)
+{
+        /* note that origin remains empty */
+
+	if (init (_path, true)) {
+		throw failed_constructor ();
+	}
+}
+
+
 /** Constructor used for existing internal-to-session files via XML.  File must exist. */
 AudioFileSource::AudioFileSource (Session& s, const XMLNode& node, bool must_exist)
 	: Source (s, node)
 
=== modified file 'libs/ardour/automation_control.cc'
--- libs/ardour/automation_control.cc	2013-09-21 19:05:02 +0000
+++ libs/ardour/automation_control.cc	2015-05-02 14:23:30 +0000
@@ -117,15 +117,23 @@
 void
 AutomationControl::start_touch(double when)
 {
-	set_touching (true);
-	alist()->start_touch(when);
-	AutomationWatch::instance().add_automation_watch (shared_from_this());
+	if (!touching()) {
+		if (alist()->automation_state() == Touch) {
+			alist()->start_touch (when);
+			AutomationWatch::instance().add_automation_watch (shared_from_this());
+		}
+		set_touching (true);
+	}
 }
 
 void
 AutomationControl::stop_touch(bool mark, double when)
 {
-	set_touching (false);
-	alist()->stop_touch (mark, when);
-	AutomationWatch::instance().remove_automation_watch (shared_from_this());
+	if (touching()) {
+		set_touching (false);
+		if (alist()->automation_state() == Touch) {
+			alist()->stop_touch (mark, when);
+			AutomationWatch::instance().remove_automation_watch (shared_from_this());
+		}
+	}
 }
 
=== modified file 'libs/ardour/automation_watch.cc'
--- libs/ardour/automation_watch.cc	2013-09-21 19:05:02 +0000
+++ libs/ardour/automation_watch.cc	2015-05-02 14:23:30 +0000
@@ -122,7 +122,7 @@
 
 		for (AutomationWatches::iterator aw = automation_watches.begin(); aw != automation_watches.end(); ++aw) {
 			if ((*aw)->alist()->automation_write()) {
-				(*aw)->list()->add (time, (*aw)->user_double());
+				(*aw)->list()->add (time, (*aw)->user_double(), true);
 			}
 		}
 	}
 
=== modified file 'libs/ardour/coreaudiosource.cc'
--- libs/ardour/coreaudiosource.cc	2013-09-21 19:05:02 +0000
+++ libs/ardour/coreaudiosource.cc	2015-05-02 14:23:30 +0000
@@ -28,6 +28,8 @@
 #include <appleutility/CAAudioFile.h>
 #include <appleutility/CAStreamBasicDescription.h>
 
+#include <glibmm/fileutils.h>
+
 #include "i18n.h"
 
 #include <AudioToolbox/AudioFormat.h>
@@ -36,21 +38,32 @@
 using namespace ARDOUR;
 using namespace PBD;
 
+/** Create a new CoreAudioSource using session state, which implies that the
+ *  file must already exist.
+ */
 CoreAudioSource::CoreAudioSource (Session& s, const XMLNode& node)
 	: Source (s, node)
 	, AudioFileSource (s, node)
 {
 	init_cafile ();
+
+        assert (Glib::file_test (_path, Glib::FILE_TEST_EXISTS));
+	existence_check ();
 }
 
+/** Create a new CoreAudioSource from an existing file. Sources created with this
+ *  method are never writable or removable.
+ */
 CoreAudioSource::CoreAudioSource (Session& s, const string& path, int chn, Flag flags)
-	/* files created this way are never writable or removable */
 	: Source (s, DataType::AUDIO, path, Source::Flag (flags & ~(Writable|Removable|RemovableIfEmpty|RemoveAtDestroy))),
 		AudioFileSource (s, path,
 			Source::Flag (flags & ~(Writable|Removable|RemovableIfEmpty|RemoveAtDestroy)))
 {
 	_channel = chn;
 	init_cafile ();
+
+        assert (Glib::file_test (_path, Glib::FILE_TEST_EXISTS));
+	existence_check ();
 }
 
 void
 
=== modified file 'libs/ardour/delivery.cc'
--- libs/ardour/delivery.cc	2014-01-24 16:31:54 +0000
+++ libs/ardour/delivery.cc	2015-05-02 14:23:30 +0000
@@ -397,7 +397,11 @@
 	if (panners_legal) {
 		if (!_no_panner_reset) {
 
+<<<<<<< TREE
 			if (_panshell && _role != Insert) {
+=======
+			if (_panshell && _role != Insert && _role != Listen) {
+>>>>>>> MERGE-SOURCE
 				_panshell->configure_io (ChanCount (DataType::AUDIO, pans_required()), ChanCount (DataType::AUDIO, pan_outs()));
 			}
 		}
 
=== modified file 'libs/ardour/diskstream.cc'
--- libs/ardour/diskstream.cc	2013-09-21 19:05:02 +0000
+++ libs/ardour/diskstream.cc	2015-05-02 14:23:30 +0000
@@ -739,4 +739,3 @@
 {
 	g_atomic_int_set (&_record_enabled, 0);
 }
-
 
=== modified file 'libs/ardour/enums.cc'
--- libs/ardour/enums.cc	2013-12-23 22:07:52 +0000
+++ libs/ardour/enums.cc	2015-05-02 14:23:30 +0000
@@ -447,6 +447,7 @@
 	REGISTER_CLASS_ENUM (Source, RemoveAtDestroy);
 	REGISTER_CLASS_ENUM (Source, NoPeakFile);
 	REGISTER_CLASS_ENUM (Source, Destructive);
+	REGISTER_CLASS_ENUM (Source, Empty);
 	REGISTER_BITS (_Source_Flag);
 
 	REGISTER_ENUM (FadeLinear);
 
=== modified file 'libs/ardour/export_channel.cc'
--- libs/ardour/export_channel.cc	2013-12-23 22:07:52 +0000
+++ libs/ardour/export_channel.cc	2015-05-02 14:23:30 +0000
@@ -239,7 +239,7 @@
 {
 	assert(processor);
 	AudioBuffer const & buffer = processor->get_capture_buffers().get_audio (channel);
-	assert (frames <= (framecnt_t) buffer.size());
+	assert (frames <= (framecnt_t) buffer.capacity());
 	data = buffer.data();
 }
 
 
=== modified file 'libs/ardour/file_source.cc'
--- libs/ardour/file_source.cc	2013-09-21 19:05:02 +0000
+++ libs/ardour/file_source.cc	2015-05-02 14:23:30 +0000
@@ -56,14 +56,12 @@
 FileSource::FileSource (Session& session, DataType type, const string& path, const string& origin, Source::Flag flag)
 	: Source(session, type, path, flag)
 	, _path (path)
-	, _file_is_new (!origin.empty()) // origin empty => new file VS. origin !empty => new file
+	, _file_is_new (!origin.empty()) // if origin is left unspecified (empty string) then file must exist
 	, _channel (0)
         , _origin (origin)
         , _open (false)
 {
 	set_within_session_from_path (path);
-
-        prevent_deletion ();
 }
 
 FileSource::FileSource (Session& session, const XMLNode& node, bool /*must_exist*/)
@@ -77,23 +75,28 @@
 
 	_path = _name;
 	_within_session = true;
-
-        prevent_deletion ();
+}
+
+FileSource::~FileSource()
+{
+}
+
+void
+FileSource::existence_check ()
+{
+        if (Glib::file_test (_path, Glib::FILE_TEST_EXISTS)) {
+		prevent_deletion ();
+	}
 }
 
 void
 FileSource::prevent_deletion ()
 {
-        /* if this file already exists, it cannot be removed, ever
-         */
-
-        if (Glib::file_test (_path, Glib::FILE_TEST_EXISTS)) {
-                if (!(_flags & Destructive)) {
-                        mark_immutable ();
-                } else {
-                        _flags = Flag (_flags & ~(Removable|RemovableIfEmpty|RemoveAtDestroy));
-                }
-        }
+	if (!(_flags & Destructive)) {
+		mark_immutable ();
+	} else {
+		_flags = Flag (_flags & ~(Removable|RemovableIfEmpty|RemoveAtDestroy));
+	}
 }
 
 bool
@@ -101,7 +104,7 @@
 {
         bool r = ((_flags & Removable)
                   && ((_flags & RemoveAtDestroy) ||
-                      ((_flags & RemovableIfEmpty) && empty() == 0)));
+                      ((_flags & RemovableIfEmpty) && empty())));
 
         return r;
 }
@@ -211,7 +214,7 @@
 
 	if (move_dependents_to_trash() != 0) {
 		/* try to back out */
-		rename (newpath.c_str(), _path.c_str());
+		::rename (newpath.c_str(), _path.c_str());
 		return -1;
 	}
 
@@ -253,8 +256,6 @@
 
                 split (search_path, dirs, ':');
 
-                hits.clear ();
-
                 for (vector<string>::iterator i = dirs.begin(); i != dirs.end(); ++i) {
 
                         fullpath = Glib::build_filename (*i, path);
@@ -309,9 +310,9 @@
 			/* no match: error */
 
                         if (must_exist) {
-                                error << string_compose(
-                                        _("Filesource: cannot find required file (%1): while searching %2"),
-                                        path, search_path) << endmsg;
+				/* do not generate an error here, leave that to
+				   whoever deals with the false return value.
+				*/
                                 goto out;
                         } else {
                                 isnew = true;
@@ -322,16 +323,17 @@
 			
 			keeppath = de_duped_hits[0];
 		}
-						  
-        } else {
+						   
+       } else {
                 keeppath = path;
         }
 
         /* Current find() is unable to parse relative path names to yet non-existant
            sources. QuickFix(tm)
         */
-        if (keeppath == "") {
-                if (must_exist) {
+
+	if (keeppath.empty()) {
+		if (must_exist) {
                         error << "FileSource::find(), keeppath = \"\", but the file must exist" << endl;
                 } else {
                         keeppath = path;
@@ -518,35 +520,6 @@
 	return ret;
 }
 
-int
-FileSource::set_source_name (const string& newname, bool destructive)
-{
-	Glib::Threads::Mutex::Lock lm (_lock);
-	string oldpath = _path;
-	string newpath = _session.change_source_path_by_name (oldpath, _name, newname, destructive);
-
-	if (newpath.empty()) {
-		error << string_compose (_("programming error: %1"), "cannot generate a changed file path") << endmsg;
-		return -1;
-	}
-
-	// Test whether newpath exists, if yes notify the user but continue.
-	if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
-		error << string_compose (_("Programming error! %1 tried to rename a file over another file! It's safe to continue working, but please report this to the developers."), PROGRAM_NAME) << endmsg;
-		return -1;
-	}
-
-        if (::rename (oldpath.c_str(), newpath.c_str()) != 0) {
-                error << string_compose (_("cannot rename file %1 to %2 (%3)"), oldpath, newpath, strerror(errno)) << endmsg;
-                return -1;
-        }
-
-	_name = Glib::path_get_basename (newpath);
-	_path = newpath;
-
-	return 0;
-}
-
 void
 FileSource::mark_immutable ()
 {
@@ -589,3 +562,46 @@
         Source::inc_use_count ();
 }
 
+bool
+FileSource::is_stub () const
+{
+	if (!empty()) {
+		return false;
+	}
+	
+	if (!removable()) {
+		return false;
+	}
+
+	if (Glib::file_test (_path, Glib::FILE_TEST_EXISTS)) {
+		return false;
+	}
+
+	return true;
+}
+		
+int
+FileSource::rename (const string& newpath)
+{
+	Glib::Threads::Mutex::Lock lm (_lock);
+	string oldpath = _path;
+
+	// Test whether newpath exists, if yes notify the user but continue.
+	if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
+		error << string_compose (_("Programming error! %1 tried to rename a file over another file! It's safe to continue working, but please report this to the developers."), PROGRAM_NAME) << endmsg;
+		return -1;
+	}
+
+	if (Glib::file_test (oldpath.c_str(), Glib::FILE_TEST_EXISTS)) { 
+		/* rename only needed if file exists on disk */
+		if (::rename (oldpath.c_str(), newpath.c_str()) != 0) {
+			error << string_compose (_("cannot rename file %1 to %2 (%3)"), oldpath, newpath, strerror(errno)) << endmsg;
+			return -1;
+		}
+	}
+
+	_name = Glib::path_get_basename (newpath);
+	_path = newpath;
+
+	return 0;
+}
 
=== modified file 'libs/ardour/filter.cc'
--- libs/ardour/filter.cc	2013-09-21 19:05:02 +0000
+++ libs/ardour/filter.cc	2015-05-02 14:23:30 +0000
@@ -59,10 +59,9 @@
 			}
 		}
 
-		string path = session.path_from_region_name (region->data_type(),
-				PBD::basename_nosuffix (names[i]), string (""));
+		string path = session.new_audio_source_path (name, region->n_channels(), i, false, false);
 
-		if (path.length() == 0) {
+		if (path.empty()) {
 			error << string_compose (_("filter: error creating name for new file based on %1"), region->name())
 			      << endmsg;
 			return -1;
 
=== modified file 'libs/ardour/import.cc'
--- libs/ardour/import.cc	2013-09-21 19:05:02 +0000
+++ libs/ardour/import.cc	2015-05-02 14:23:30 +0000
@@ -116,78 +116,31 @@
 	}
 }
 
-static std::string
-get_non_existent_filename (HeaderFormat hf, DataType type, const bool allow_replacing, const std::string& destdir, const std::string& basename, uint channel, uint channels)
-{
-	char buf[PATH_MAX+1];
-	bool goodfile = false;
-	string base = basename;
-	string ext = native_header_format_extension (hf, type);
-	uint32_t cnt = 1;
-
-	do {
-
-		if (type == DataType::AUDIO && channels == 2) {
-			if (channel == 0) {
-				if (cnt == 1) {
-					snprintf (buf, sizeof(buf), "%s-L%s", base.c_str(), ext.c_str());
-				} else {
-					snprintf (buf, sizeof(buf), "%s-%d-L%s", base.c_str(), cnt, ext.c_str());
-				}
-			} else {
-				if (cnt == 1) {
-					snprintf (buf, sizeof(buf), "%s-R%s", base.c_str(), ext.c_str());
-				} else {
-					snprintf (buf, sizeof(buf), "%s-%d-R%s", base.c_str(), cnt, ext.c_str());
-				}
-			}
-		} else if (channels > 1) {
-			if (cnt == 1) {
-				snprintf (buf, sizeof(buf), "%s-c%d%s", base.c_str(), channel, ext.c_str());
-			} else {
-				snprintf (buf, sizeof(buf), "%s-%d-c%d%s", base.c_str(), cnt, channel, ext.c_str());
-			}
-		} else {
-			if (cnt == 1) {
-				snprintf (buf, sizeof(buf), "%s%s", base.c_str(), ext.c_str());
-			} else {
-				snprintf (buf, sizeof(buf), "%s-%d%s", base.c_str(), cnt, ext.c_str());
-			}
-		}
-
-		string tempname = destdir + "/" + buf;
-
-		if (!allow_replacing && Glib::file_test (tempname, Glib::FILE_TEST_EXISTS)) {
-
-			cnt++;
-
-		} else {
-
-			goodfile = true;
-		}
-
-	} while (!goodfile);
-
-	return buf;
-}
-
-static vector<string>
-get_paths_for_new_sources (HeaderFormat hf, const bool allow_replacing, const string& import_file_path, const string& session_dir, uint channels)
+vector<string>
+Session::get_paths_for_new_sources (bool /*allow_replacing*/, const string& import_file_path, uint32_t channels)
 {
 	vector<string> new_paths;
 	const string basename = basename_nosuffix (import_file_path);
 
-	SessionDirectory sdir(session_dir);
-
 	for (uint n = 0; n < channels; ++n) {
 
 		const DataType type = SMFSource::safe_midi_file_extension (import_file_path) ? DataType::MIDI : DataType::AUDIO;
-
-		std::string filepath = (type == DataType::MIDI)
-			? sdir.midi_path() : sdir.sound_path();
-
-		filepath = Glib::build_filename (filepath,
-		                                 get_non_existent_filename (hf, type, allow_replacing, filepath, basename, n, channels));
+		string filepath;
+
+		switch (type) {
+		  case DataType::MIDI:
+			filepath = new_midi_source_path (basename);
+			break;
+		case DataType::AUDIO:
+			filepath = new_audio_source_path (basename, channels, n, false, false);
+			break;
+		}
+
+		if (filepath.empty()) {
+			error << string_compose (_("Cannot find new filename for imported file %1"), import_file_path) << endmsg;
+			return vector<string>();
+		}
+
 		new_paths.push_back (filepath);
 	}
 
@@ -201,7 +154,7 @@
 	for (vector<string>::const_iterator i = new_paths.begin();
 	     i != new_paths.end(); ++i)
 	{
-		boost::shared_ptr<Source> source = session->source_by_path_and_channel(*i, 0);
+		boost::shared_ptr<Source> source = session->audio_source_by_path_and_channel(*i, 0);
 
 		if (source == 0) {
 			error << string_compose(_("Could not find a source for %1 even though we are updating this file!"), (*i)) << endl;
@@ -274,12 +227,12 @@
 {
 	const framecnt_t nframes = ResampledImportableSource::blocksize;
 	boost::shared_ptr<AudioFileSource> afs;
-	uint channels = source->channels();
+	uint32_t channels = source->channels();
 
 	boost::scoped_array<float> data(new float[nframes * channels]);
 	vector<boost::shared_array<Sample> > channel_data;
 
-	for (uint n = 0; n < channels; ++n) {
+	for (uint32_t n = 0; n < channels; ++n) {
 		channel_data.push_back(boost::shared_array<Sample>(new Sample[nframes]));
 	}
 
@@ -323,14 +276,14 @@
 		progress_multiplier = 0.5;
 		progress_base = 0.5;
 	}
-
-	uint read_count = 0;
+	
+	framecnt_t read_count = 0;
 
 	while (!status.cancel) {
 
 		framecnt_t nread, nfread;
-		uint x;
-		uint chn;
+		uint32_t x;
+		uint32_t chn;
 
 		if ((nread = source->read (data.get(), nframes)) == 0) {
 			break;
@@ -513,10 +466,7 @@
 			}
 		}
 
-		vector<string> new_paths = get_paths_for_new_sources (config.get_native_file_header_format(),
-		                                                      status.replace_existing_source, *p,
-		                                                      get_best_session_directory_for_new_source (),
-		                                                      channels);
+		vector<string> new_paths = get_paths_for_new_sources (status.replace_existing_source, *p, channels);
 		Sources newfiles;
 		framepos_t natural_position = source ? source->natural_position() : 0;
 
 
=== modified file 'libs/ardour/internal_send.cc'
--- libs/ardour/internal_send.cc	2014-01-24 16:31:54 +0000
+++ libs/ardour/internal_send.cc	2015-05-02 14:23:30 +0000
@@ -129,7 +129,7 @@
 	// we have to copy the input, because we may alter the buffers with the amp
 	// in-place, which a send must never do.
 
-	if (_panshell && !_panshell->bypassed()) {
+	if (_panshell && !_panshell->bypassed() && role() != Listen) {
 		_panshell->run (bufs, mixbufs, start_frame, end_frame, nframes);
 	} else {
 		if (role() == Listen) {
 
=== modified file 'libs/ardour/lv2_evbuf.c'
--- libs/ardour/lv2_evbuf.c	2013-09-21 19:05:02 +0000
+++ libs/ardour/lv2_evbuf.c	2015-05-02 14:23:30 +0000
@@ -203,7 +203,7 @@
 	switch (iter.evbuf->type) {
 	case LV2_EVBUF_EVENT:
 		ebuf = &iter.evbuf->buf.event;
-		ev = (LV2_Event*)ebuf->data + iter.offset;
+		ev = (LV2_Event*)((char*)ebuf->data + iter.offset);
 		*frames    = ev->frames;
 		*subframes = ev->subframes;
 		*type      = ev->type;
 
=== modified file 'libs/ardour/lv2_plugin.cc'
--- libs/ardour/lv2_plugin.cc	2014-01-24 16:31:54 +0000
+++ libs/ardour/lv2_plugin.cc	2015-05-02 14:23:30 +0000
@@ -31,6 +31,7 @@
 
 #include <boost/utility.hpp>
 
+#include "pbd/clear_dir.h"
 #include "pbd/pathscanner.h"
 #include "pbd/compose.h"
 #include "pbd/error.h"
@@ -880,27 +881,6 @@
 	return g_strndup(abs_path.c_str(), abs_path.length());
 }
 
-static void
-remove_directory(const std::string& path)
-{