diff --git a/session_utils/new_aaf_session.cc b/session_utils/new_aaf_session.cc
new file mode 100644
index 0000000000..0d47327a72
--- /dev/null
+++ b/session_utils/new_aaf_session.cc
@@ -0,0 +1,1306 @@
+/*
+ * Copyright (C) 2023 Adrien Gesta-Fline <dev.agfline@posteo.net>
+ * Based on Robin Gareus <robin@gareus.org> session_utils files
+ * Based on Damien Zammit ptformat
+ *
+ * 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.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include <cstdlib>
+#include <getopt.h>
+#include <glibmm.h>
+#include <iostream>
+#include <locale.h>
+#include <unistd.h>
+
+#include <libxml/parser.h>
+#include <libxml/tree.h>
+#include <libxml/xpath.h>
+#include <libxml/xpathInternals.h>
+
+#include "ardour/audioengine.h"
+#include "ardour/filename_extensions.h"
+#include "ardour/session_directory.h"
+#include "ardour/template_utils.h"
+
+#include "ardour/audio_track.h"
+#include "ardour/audiofilesource.h"
+#include "ardour/audioregion.h"
+#include "ardour/import_status.h"
+#include "ardour/playlist.h"
+#include "ardour/region_factory.h"
+#include "ardour/source_factory.h"
+
+#include "common.h"
+#include "pbd/file_utils.h"
+
+#include "aaf/libaaf.h"
+#include "aaf/utils.h"
+
+using namespace std;
+using namespace ARDOUR;
+using namespace SessionUtils;
+using namespace Timecode;
+using namespace PBD;
+
+#ifndef UTILNAME
+#define UTILNAME "new_aaf_session"
+#endif
+
+/*
+ *  TODO:
+ *    - Track level
+ *    - Track pan
+ *    - Track level automation
+ *    - Track pan automation
+ *    x Region level automation
+ *    - Session timecode offset (so the very begining of the timeline starts at eg. 01:00:00:00)
+ *    x Markers
+ *    x Multichannel audio file import (AAFOperationDef_AudioChannelCombiner)
+ *    - Multichannel region from multiple source audio files (1 file per channel) ?
+ *    - Mono region from a specific channel of a multichannel file ?
+ *    x Muted region
+ *    - Video file import
+ */
+
+#define PRINT_I(fmt, ...)                                                                                                                 \
+	{                                                                                                                                 \
+		fprintf (stderr, "[\033[1;38;5;81mi\x1B[0m] \x1b[38;5;239m%s : %s() on line %i :\x1B[0m ", __FILE__, __func__, __LINE__); \
+		fprintf (stderr, fmt, ##__VA_ARGS__);                                                                                     \
+	}
+#define PRINT_W(fmt, ...)                                                                                                          \
+	{                                                                                                                          \
+		fprintf (stderr, "[\x1B[33mw\x1B[0m] \x1b[38;5;239m%s : %s() on line %i :\x1B[0m ", __FILE__, __func__, __LINE__); \
+		fprintf (stderr, fmt, ##__VA_ARGS__);                                                                              \
+	}
+#define PRINT_E(fmt, ...)                                                                                                          \
+	{                                                                                                                          \
+		fprintf (stderr, "[\x1B[31me\x1B[0m] \x1b[38;5;239m%s : %s() on line %i :\x1B[0m ", __FILE__, __func__, __LINE__); \
+		fprintf (stderr, fmt, ##__VA_ARGS__);                                                                              \
+	}
+
+static void
+usage ();
+static void
+list_templates ();
+static std::string
+template_path_from_name (std::string const& name);
+static Session*
+create_new_session (string const& dir, string const& state, float samplerate, ARDOUR::SampleFormat bitdepth, int master_bus_chn, string const& template_path);
+// static void set_session_video_from_aaf( Session *s, AAF_Iface *aafi );
+static std::shared_ptr<AudioTrack>
+get_nth_audio_track (uint32_t nth, std::shared_ptr<RouteList const> routes);
+static bool
+import_sndfile_as_region (Session* s, struct aafiAudioEssence* audioEssence, SrcQuality quality, timepos_t& pos, SourceList& sources, ImportStatus& status, vector<std::shared_ptr<Region>>* regions /* boost::shared_ptr<Region> r*/);
+static void
+set_session_range (Session* s, AAF_Iface* aafi);
+static std::shared_ptr<Region>
+create_region (vector<std::shared_ptr<Region>> source_regions, aafiAudioClip* aafAudioClip, SourceList& oneClipSources, aafPosition_t clipOffset, aafRational_t samplerate_r);
+static void
+set_region_gain (aafiAudioClip* aafAudioClip, std::shared_ptr<Region> region, Session* s);
+static std::shared_ptr<AudioTrack>
+prepare_audio_track (aafiAudioTrack* aafTrack, Session* s);
+static void
+set_region_fade (aafiAudioClip* aafAudioClip, std::shared_ptr<Region> region, aafRational_t* samplerate);
+static void
+set_session_timecode (Session* s, AAF_Iface* aafi);
+
+static void
+usage ()
+{
+	// help2man compatible format (standard GNU help-text)
+	printf (UTILNAME " - create a new session based on an AAF file from the commandline.\n\n");
+	printf ("Usage: " UTILNAME " [ OPTIONS ] -p <session-path> --aaf <file.aaf>\n\n");
+	printf ("Options:\n\n\
+  -h, --help                        Display this help and exit.\n\
+  -L, --list-templates              List available Ardour templates and exit.\n\
+\n\
+  -m, --master-channels      <chn>  Master-bus channel count (default 2).\n\
+  -r, --sample-rate         <rate>  Sample rate of the new Ardour session (default is AAF).\n\
+  -s, --sample-size     <16|24|32>  Audio bit depth of the new Ardour session (default is AAF).\n\
+\n\
+  -t, --template        <template>  Use given template for new session.\n\
+  -p, --session-path        <path>  Where to store the new session folder.\n\
+  -n, --session-name        <name>  The new session name. A new folder will be created into session path with that name.\n\
+                                    Default is the AAF composition name or file name as a fallback.\n\
+                                    Set <name> to AAFFILE to force the use of AAF file name as session name.\n\
+\n\
+  -l, --media-location      <path>  Path to AAF media files (when not embedded)\n\
+  -c, --media-cache         <path>  Path where AAF embedded media files will be extracted, prior to Ardour import. Default is TEMP.\n\
+  -k, --keep-cache                  Do not clear cache. Useful for analysis of extracted audio files.\n\
+\n\
+  -a, --aaf             <aaf file>  AAF file to load.\n\
+\n\
+Vendor Options:\n\
+\n\
+  Davinci Resolve\n\
+\n\
+  --import-disabled-clips           Import disabled clips (skipped by default)\n\
+\n\
+  Pro Tools\n\
+\n\
+  --remove-sample-accurate-edit     Remove clips added by PT to pad to frame boundary.\n\
+  --convert-fade-clips              Remove clip fades and replace by real fades.\n\
+\n\
+\n");
+
+	printf ("\n\
+Examples:\n\
+" UTILNAME " --session-path /path/to/sessions/ --aaf /path/to/file.aaf\n\
+\n");
+
+	printf ("Report bugs to <http://tracker.ardour.org/>\n"
+	        "Website: <http://ardour.org/>\n");
+	::exit (EXIT_SUCCESS);
+}
+
+static void
+list_templates ()
+{
+	vector<TemplateInfo> templates;
+	find_session_templates (templates, false);
+
+	for (vector<TemplateInfo>::iterator x = templates.begin (); x != templates.end (); ++x) {
+		printf ("%s\n", (*x).name.c_str ());
+	}
+}
+
+static std::string
+template_path_from_name (std::string const& name)
+{
+	vector<TemplateInfo> templates;
+	find_session_templates (templates, false);
+
+	for (vector<TemplateInfo>::iterator x = templates.begin (); x != templates.end (); ++x) {
+		if ((*x).name == name)
+			return (*x).path;
+	}
+
+	return "";
+}
+
+static Session*
+create_new_session (string const& dir, string const& state, float samplerate, ARDOUR::SampleFormat bitdepth, int master_bus_chn, string const& template_path)
+{
+	AudioEngine* engine = AudioEngine::create ();
+
+	if (!engine->set_backend ("None (Dummy)", "Unit-Test", "")) {
+		PRINT_E ("Cannot create Audio/MIDI engine.\n");
+		return NULL;
+	}
+
+	// engine->set_input_channels( 32 );
+	// engine->set_output_channels( 32 );
+
+	if (engine->set_sample_rate (samplerate)) {
+		PRINT_E ("Cannot set session's samplerate to %lf.\n", samplerate);
+		return NULL;
+	}
+
+	if (engine->start () != 0) {
+		PRINT_E ("Cannot start Audio/MIDI engine.\n");
+		return NULL;
+	}
+
+	string s = Glib::build_filename (dir, state + statefile_suffix);
+
+	if (Glib::file_test (dir, Glib::FILE_TEST_EXISTS)) {
+		PRINT_E ("Session folder already exists '%s'\n", dir.c_str ());
+		return NULL;
+	}
+
+	if (Glib::file_test (s, Glib::FILE_TEST_EXISTS)) {
+		PRINT_E ("Session file exists '%s'\n", s.c_str ());
+		return NULL;
+	}
+
+	BusProfile  bus_profile;
+	BusProfile* bus_profile_ptr = NULL;
+
+	if (master_bus_chn > 0) {
+		bus_profile_ptr                 = &bus_profile;
+		bus_profile.master_out_channels = master_bus_chn;
+	}
+
+	if (!template_path.empty ()) {
+		bus_profile_ptr = NULL;
+	}
+
+	Session* session = new Session (*engine, dir, state, bus_profile_ptr, template_path);
+
+	engine->set_session (session);
+
+	session->config.set_native_file_data_format (bitdepth);
+
+	return session;
+}
+
+/*
+ * libs/ardour/import.cc
+ * - Reimplement since function was removed in 4620d13 : https://github.com/Ardour/ardour/commit/4620d138eefad57bc55e1901d8410c36803ce0d6 -
+ */
+
+static std::shared_ptr<AudioTrack>
+get_nth_audio_track (uint32_t nth, std::shared_ptr<RouteList const> routes)
+{
+	RouteList rl = *(routes);
+	rl.sort (Stripable::Sorter ());
+
+	for (auto const& r : rl) {
+		std::shared_ptr<AudioTrack> at = std::dynamic_pointer_cast<AudioTrack> (r);
+		if (!at) {
+			continue;
+		}
+		if (nth-- == 0) {
+			return at;
+		}
+	}
+	return std::shared_ptr<AudioTrack> ();
+}
+
+/*
+ * https://github.com/Ardour/ardour/blob/365f6d633731229e7bc5d37a5fe2c9107b527e28/libs/ardour/import_pt.cc#L82
+ */
+
+static bool
+import_sndfile_as_region (Session* s, struct aafiAudioEssence* audioEssence, SrcQuality quality, timepos_t& pos, SourceList& sources, ImportStatus& status, vector<std::shared_ptr<Region>>* regions /* boost::shared_ptr<Region> r*/)
+{
+	wstring ws (audioEssence->usable_file_path);
+	string  usable_file_path (ws.begin (), ws.end ());
+
+	/* Import the source */
+	status.paths.clear ();
+	status.paths.push_back (usable_file_path);
+	status.current                 = 1;
+	status.total                   = 1;
+	status.freeze                  = false;
+	status.quality                 = quality;
+	status.replace_existing_source = false;
+	status.split_midi_channels     = false;
+	status.import_markers          = false;
+	status.done                    = false;
+	status.cancel                  = false;
+
+	s->import_files (status);
+
+	status.progress = 1.0;
+	sources.clear ();
+
+	/* FIXME: There is no way to tell if cancel button was pressed
+	 * or if the file failed to import, just that one of these occurred.
+	 * We want status.cancel to reflect the user's choice only
+	 */
+	if (status.cancel && status.current > 1) {
+		/* Succeeded to import file, assume user hit cancel */
+		return false;
+	} else if (status.cancel && status.current == 1) {
+		/* Failed to import file, assume user did not hit cancel */
+		status.cancel = false;
+		return false;
+	}
+
+	for (int i = 0; i < audioEssence->channels; i++) {
+		sources.push_back (status.sources.at (i));
+	}
+
+	/* build peakfiles */
+	for (SourceList::iterator x = sources.begin (); x != sources.end (); ++x) {
+		SourceFactory::setup_peakfile (*x, true);
+	}
+
+	/* Put the source on a region */
+	std::shared_ptr<Region> region;
+	string                  region_name;
+
+	/* take all the sources we have and package them up as a region */
+
+	region_name = region_name_from_path (status.paths.front (), (sources.size () > 1), false);
+
+	/* we checked in import_sndfiles() that there were not too many */
+
+	while (RegionFactory::region_by_name (region_name)) {
+		region_name = bump_name_once (region_name, '.');
+	}
+
+	ws = audioEssence->unique_file_name;
+	string unique_file_name (ws.begin (), ws.end ());
+
+	PropertyList proplist;
+
+	proplist.add (ARDOUR::Properties::start, 0);
+	proplist.add (ARDOUR::Properties::length, timecnt_t (sources[0]->length (), pos));
+	proplist.add (ARDOUR::Properties::name, unique_file_name);
+	proplist.add (ARDOUR::Properties::layer, 0);
+	proplist.add (ARDOUR::Properties::whole_file, true);
+	proplist.add (ARDOUR::Properties::external, true);
+
+	region = RegionFactory::create (sources, proplist);
+	(*regions).push_back (region);
+
+	/* NOTE: Don't know what that's for */
+
+	// bool use_timestamp;
+	// use_timestamp = (pos == -1);
+	// if (use_timestamp && boost::dynamic_pointer_cast<AudioRegion>(r)) {
+	// 	boost::dynamic_pointer_cast<AudioRegion>(r)->special_set_position(sources[0]->natural_position());
+	// }
+	//
+	//
+	// /* if we're creating a new track, name it after the cleaned-up
+	//  * and "merged" region name.
+	//  */
+	//
+	// regions.push_back (r);
+	// int n = 0;
+	//
+	// 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);
+	//
+	// 	if (use_timestamp) {
+	// 		if (ar) {
+	//
+	// 			/* get timestamp for this region */
+	//
+	// 			const boost::shared_ptr<Source> s (ar->sources().front());
+	// 			const boost::shared_ptr<AudioSource> as = boost::dynamic_pointer_cast<AudioSource> (s);
+	//
+	// 			assert (as);
+	//
+	// 			if (as->natural_position() != 0) {
+	// 				pos = as->natural_position();
+	// 			} else {
+	// 				pos = 0;
+	// 			}
+	// 		} else {
+	// 			/* should really get first position in MIDI file, but for now, use 0 */
+	// 			pos = 0;
+	// 		}
+	// 	}
+	// }
+
+	return true;
+}
+
+static void
+set_session_range (Session* s, AAF_Iface* aafi)
+{
+	samplepos_t start = samplepos_t (eu2sample (s->sample_rate (), &aafi->compositionStart_editRate, aafi->compositionStart));
+	samplepos_t end   = samplepos_t (eu2sample (s->sample_rate (), &aafi->compositionLength_editRate, aafi->compositionLength)) + start;
+
+	/* https://github.com/agfline/LibAAF/issues/5#issuecomment-1632522578 */
+	// s->set_session_extents( timepos_t(start), timepos_t(end) );
+	s->maybe_update_session_range (timepos_t (start), timepos_t (end));
+}
+
+static std::shared_ptr<Region>
+create_region (vector<std::shared_ptr<Region>> source_regions, aafiAudioClip* aafAudioClip, SourceList& oneClipSources, aafPosition_t clipOffset, aafRational_t samplerate_r)
+{
+	wstring ws = aafAudioClip->Essence->unique_file_name;
+	string  unique_file_name (ws.begin (), ws.end ());
+
+	aafPosition_t clipPos       = convertEditUnit (aafAudioClip->pos, *aafAudioClip->track->edit_rate, samplerate_r);
+	aafPosition_t clipLen       = convertEditUnit (aafAudioClip->len, *aafAudioClip->track->edit_rate, samplerate_r);
+	aafPosition_t essenceOffset = convertEditUnit (aafAudioClip->essence_offset, *aafAudioClip->track->edit_rate, samplerate_r);
+
+	PropertyList proplist;
+
+	proplist.add (ARDOUR::Properties::start, essenceOffset);
+	proplist.add (ARDOUR::Properties::length, clipLen);
+	proplist.add (ARDOUR::Properties::name, unique_file_name);
+	proplist.add (ARDOUR::Properties::layer, 0);
+	proplist.add (ARDOUR::Properties::whole_file, false);
+	proplist.add (ARDOUR::Properties::external, true);
+
+	/* NOTE: region position is set when calling add_region() */
+
+	std::shared_ptr<Region> region = RegionFactory::create (oneClipSources, proplist);
+
+	for (SourceList::iterator source = oneClipSources.begin (); source != oneClipSources.end (); ++source) {
+		/* position displayed in Ardour source list */
+		(*source)->set_natural_position (timepos_t (clipPos + clipOffset));
+
+		for (vector<std::shared_ptr<Region>>::iterator region = source_regions.begin (); region != source_regions.end (); ++region) {
+			if ((*region)->source (0) == *source) {
+				/* Enable "Move to Original Position" */
+				(*region)->set_position (timepos_t (clipPos + clipOffset - essenceOffset));
+			}
+		}
+	}
+
+	return region;
+}
+
+static void
+set_region_gain (aafiAudioClip* aafAudioClip, std::shared_ptr<Region> region, Session* s)
+{
+	if (aafAudioClip->gain && aafAudioClip->gain->flags & AAFI_AUDIO_GAIN_CONSTANT) {
+		std::dynamic_pointer_cast<AudioRegion> (region)->set_scale_amplitude (aafRationalToFloat (aafAudioClip->gain->value[0]));
+	}
+
+	if (aafAudioClip->automation) {
+		aafiAudioGain*                  level = aafAudioClip->automation;
+		std::shared_ptr<AudioRegion>    ar    = std::dynamic_pointer_cast<AudioRegion> (region);
+		std::shared_ptr<AutomationList> al    = ar->envelope ();
+
+		for (int i = 0; i < level->pts_cnt; i++) {
+			al->fast_simple_add (timepos_t (aafRationalToFloat (level->time[i]) * region->length ().samples ()), aafRationalToFloat (level->value[i]));
+		}
+	}
+}
+
+static std::shared_ptr<AudioTrack>
+prepare_audio_track (aafiAudioTrack* aafTrack, Session* s)
+{
+	/*
+	 * https://github.com/Ardour/ardour/blob/365f6d633731229e7bc5d37a5fe2c9107b527e28/libs/ardour/import_pt.cc#L327
+	 */
+
+	/* Use existing track if possible */
+	std::shared_ptr<AudioTrack> track = get_nth_audio_track ((aafTrack->number - 1), s->get_routes ());
+
+	/* Or create a new track if needed */
+	if (!track) {
+		wstring ws_track_name = std::wstring (aafTrack->name);
+		string  track_name    = string (ws_track_name.begin (), ws_track_name.end ());
+
+		PRINT_I ("Track number %i (%s) does not exist. Adding new track.\n", aafTrack->number, track_name.c_str ());
+
+		// TODO: second argument is "output_channels". How should it be set ?
+		list<std::shared_ptr<AudioTrack>> at (s->new_audio_track (aafTrack->format, 2, 0, 1, track_name, PresentationInfo::max_order, Normal));
+
+		if (at.empty ()) {
+			PRINT_E ("Could not create new audio track.\n");
+			::exit (EXIT_FAILURE);
+		}
+
+		track = at.back ();
+	}
+
+	return track;
+}
+
+static FadeShape
+aaf_fade_interpol_to_ardour_fade_shape (aafiInterpolation_e interpol)
+{
+	/*
+	 * https://github.com/Ardour/ardour/blob/b84c99639f0dd28e210ed9c064429c17014093a7/libs/ardour/ardour/types.h#L705
+	 *
+	 * enum FadeShape {
+	 *   FadeLinear,
+	 *   FadeFast,
+	 *   FadeSlow,
+	 *   FadeConstantPower,
+	 *   FadeSymmetric,
+	 * };
+	 *
+	 * https://github.com/Ardour/ardour/blob/365f6d633731229e7bc5d37a5fe2c9107b527e28/libs/ardour/ardour/audioregion.h#L143
+	 * https://github.com/Ardour/ardour/blob/365f6d633731229e7bc5d37a5fe2c9107b527e28/libs/temporal/temporal/types.h#L39
+	 */
+
+	switch (interpol & AAFI_INTERPOL_MASK) {
+		case AAFI_INTERPOL_NONE:
+			PRINT_W ("Fade type is set to AAFI_INTERPOL_NONE : Falling back to FadeConstantPower.");
+			return FadeConstantPower;
+
+		case AAFI_INTERPOL_LINEAR:
+			return FadeLinear;
+
+		case AAFI_INTERPOL_LOG:
+			PRINT_W ("Fade type is set to AAFI_INTERPOL_LOG : Falling back to FadeConstantPower.");
+			return FadeConstantPower;
+
+		case AAFI_INTERPOL_CONSTANT:
+			PRINT_W ("Fade type is set to AAFI_INTERPOL_CONSTANT : Falling back to FadeConstantPower.");
+			return FadeConstantPower;
+
+		case AAFI_INTERPOL_POWER:
+			return FadeConstantPower;
+
+		case AAFI_INTERPOL_BSPLINE:
+			PRINT_W ("Fade type is set to AAFI_INTERPOL_BSPLINE : Falling back to FadeConstantPower.");
+			return FadeConstantPower;
+
+		default:
+			PRINT_W ("Unknown fade type : Falling back to FadeConstantPower.");
+			return FadeConstantPower;
+	}
+
+	PRINT_W ("Unknown fade type : Falling back to FadeConstantPower.");
+	return FadeConstantPower;
+}
+
+static void
+set_region_fade (aafiAudioClip* aafAudioClip, std::shared_ptr<Region> region, aafRational_t* samplerate)
+{
+	if (aafAudioClip == NULL) {
+		return;
+	}
+
+	aafiTransition* fadein  = aafi_get_fadein (aafAudioClip->Item);
+	aafiTransition* fadeout = aafi_get_fadeout (aafAudioClip->Item);
+	aafiTransition* xfade   = aafi_get_xfade (aafAudioClip->Item);
+
+	if (xfade) {
+		if (fadein == NULL) {
+			fadein = xfade;
+		} else {
+			PRINT_W ("Clip has both fadein and crossfade : crossfade will be ignored.");
+		}
+	}
+
+	FadeShape   fade_shape;
+	samplecnt_t fade_len;
+
+	if (fadein != NULL) {
+		fade_shape = aaf_fade_interpol_to_ardour_fade_shape ((aafiInterpolation_e)(fadein->flags & AAFI_INTERPOL_MASK));
+		fade_len   = convertEditUnit (fadein->len, *aafAudioClip->track->edit_rate, *samplerate);
+
+		std::dynamic_pointer_cast<AudioRegion> (region)->set_fade_in (fade_shape, fade_len);
+	}
+
+	if (fadeout != NULL) {
+		fade_shape = aaf_fade_interpol_to_ardour_fade_shape ((aafiInterpolation_e)(fadeout->flags & AAFI_INTERPOL_MASK));
+		fade_len   = convertEditUnit (fadeout->len, *aafAudioClip->track->edit_rate, *samplerate);
+
+		std::dynamic_pointer_cast<AudioRegion> (region)->set_fade_out (fade_shape, fade_len);
+	}
+}
+
+static void
+set_session_timecode (Session* s, AAF_Iface* aafi)
+{
+	uint16_t       aafFPS = aafi->Timecode->fps;
+	TimecodeFormat ardourtc;
+
+	/*
+	 *  Fractional timecodes are never explicitly set into tc->fps, so we deduce
+	 *  them based on edit_rate value.
+	 */
+
+	switch (aafFPS) {
+		case 24:
+			if (aafi->Timecode->edit_rate->numerator == 24000 &&
+			    aafi->Timecode->edit_rate->denominator == 1001) {
+				ardourtc = timecode_23976;
+			} else {
+				ardourtc = timecode_24;
+			}
+			break;
+
+		case 25:
+			if (aafi->Timecode->edit_rate->numerator == 25000 &&
+			    aafi->Timecode->edit_rate->denominator == 1001) {
+				ardourtc = timecode_24976;
+			} else {
+				ardourtc = timecode_25;
+			}
+			break;
+
+		case 30:
+			if (aafi->Timecode->edit_rate->numerator == 30000 &&
+			    aafi->Timecode->edit_rate->denominator == 1001) {
+				if (aafi->Timecode->drop) {
+					ardourtc = timecode_2997drop;
+				} else {
+					ardourtc = timecode_2997;
+				}
+			} else {
+				if (aafi->Timecode->drop) {
+					ardourtc = timecode_30drop;
+				} else {
+					ardourtc = timecode_30;
+				}
+			}
+			break;
+
+		case 60:
+			if (aafi->Timecode->edit_rate->numerator == 60000 &&
+			    aafi->Timecode->edit_rate->denominator == 1001) {
+				ardourtc = timecode_5994;
+			} else {
+				ardourtc = timecode_60;
+			}
+			break;
+
+		default:
+			PRINT_E ("Unknown AAF timecode fps : %i.\n", aafFPS);
+			return;
+	}
+
+	s->config.set_timecode_format (ardourtc);
+}
+
+int
+prepare_cache (AAF_Iface* aafi, string* media_cache_path)
+{
+	if (!(*media_cache_path).empty ()) {
+		/* if media cache is not empty, user forced cache path with --media-cache */
+		return 0;
+	}
+
+	const char* tmppath = g_get_tmp_dir ();
+
+	if (!aafi->compositionName || aafi->compositionName[0] == 0x00) {
+		*media_cache_path = g_build_path (G_DIR_SEPARATOR_S, tmppath, g_basename (aafi->aafd->cfbd->file), NULL); //+ string(DIR_SEP_STR);
+	} else {
+		int   compoNameLen = wcslen (aafi->compositionName) + 1;
+		char* compoName    = (char*)malloc (compoNameLen);
+
+		wcstombs (compoName, aafi->compositionName, compoNameLen);
+
+		*media_cache_path = g_build_path (G_DIR_SEPARATOR_S, tmppath, laaf_util_clean_filename (compoName), NULL);
+
+		g_free (compoName);
+	}
+
+	int    i       = 0;
+	string testdir = *media_cache_path;
+
+	while (g_file_test (testdir.c_str (), G_FILE_TEST_EXISTS))
+		testdir = *media_cache_path + "_" + to_string (i++);
+
+	*media_cache_path = testdir;
+
+	if (mkdir ((*media_cache_path).c_str (), 0760) < 0) {
+		// if ( g_mkdir_with_parents( (*media_cache_path).c_str(), 0760 ) < 0 ) {
+		PRINT_E ("Could not create cache directory at '%s' : %s\n", (*media_cache_path).c_str (), strerror (errno));
+		return -1;
+	}
+
+	return 0;
+}
+
+void
+clear_cache (AAF_Iface* aafi, string media_cache_path)
+{
+	aafiAudioEssence* audioEssence = NULL;
+
+	foreachEssence (audioEssence, aafi->Audio->Essences)
+	{
+		if (!audioEssence->is_embedded) {
+			continue;
+		}
+
+		char* filepath = (char*)malloc (wcslen (audioEssence->usable_file_path) + 1);
+		snprintf (filepath, wcslen (audioEssence->usable_file_path) + 1, "%ls", audioEssence->usable_file_path);
+
+		if (g_file_test (filepath, G_FILE_TEST_EXISTS)) {
+			if (remove (filepath) < 0) {
+				PRINT_E ("Failed to remove a file from cache (%s) : %s\n", filepath, strerror (errno));
+			}
+		} else {
+			PRINT_E ("Missing a file from cache (%s) : %s\n", filepath, strerror (errno));
+		}
+
+		free (filepath);
+	}
+
+	if (rmdir (media_cache_path.c_str ()) < 0) {
+		PRINT_E ("Failed to remove cache directory (%s) : %s\n", media_cache_path.c_str (), strerror (errno));
+	}
+}
+
+int
+main (int argc, char* argv[])
+{
+	setlocale (LC_ALL, "");
+
+	ARDOUR::SampleFormat bitdepth       = ARDOUR::FormatInt24;
+	int                  samplesize     = 0;
+	int                  samplerate     = 0;
+	int                  master_bus_chn = 2;
+	string               template_path;
+	string               output_folder;
+	string               session_name;
+	string               media_location_path;
+	string               media_cache_path;
+	int                  keep_cache = 0;
+	string               aaf_file;
+	uint32_t             aaf_resolve_options  = 0;
+	uint32_t             aaf_protools_options = 0;
+	// bool replace_session_if_exists = false;
+
+	printf ("using libaaf %s\n", LIBAAF_VERSION);
+
+	const char* optstring = "hLm:r:s:t:p:n:l:c:a:";
+
+	const struct option longopts[] = {
+		{ "help", no_argument, 0, 'h' },
+
+		{ "list-templates", no_argument, 0, 'L' },
+
+		{ "master-channels", required_argument, 0, 'm' },
+
+		{ "sample-rate", required_argument, 0, 'r' },
+		{ "sample-size", required_argument, 0, 's' },
+
+		{ "template", required_argument, 0, 't' },
+		{ "session-path", required_argument, 0, 'p' },
+		{ "session-name", required_argument, 0, 'n' },
+
+		{ "media-location", required_argument, 0, 'l' },
+		{ "media-cache", required_argument, 0, 'c' },
+		{ "keep-cache", required_argument, 0, 'k' },
+
+		{ "aaf", required_argument, 0, 'a' },
+
+		{ "import-disabled-clips", no_argument, 0, 0x01 },
+		{ "remove-sample-accurate-edit", no_argument, 0, 0x02 },
+		{ "convert-fade-clips", no_argument, 0, 0x03 },
+
+		// { "replace-session-if-exists", no_argument, 0, 0x01 }
+	};
+
+	int c = 0;
+
+	while (EOF != (c = getopt_long (argc, argv, optstring, longopts, (int*)0))) {
+		switch (c) {
+			case 'h':
+				usage ();
+				break;
+
+			case 'L':
+				list_templates ();
+				exit (EXIT_SUCCESS);
+				break;
+
+			case 'm':
+				master_bus_chn = atoi (optarg);
+				/* TODO check min / max */
+				break;
+
+			case 'r':
+				samplerate = atoi (optarg);
+
+				if (samplerate < 44100 || samplerate > 192000) {
+					PRINT_E ("Invalid sample rate (%s). Sample rate must be between 44100 and 192000.\n", optarg);
+					::exit (EXIT_FAILURE);
+				}
+				break;
+
+			case 's':
+				samplesize = atoi (optarg);
+
+				if (samplesize != 16 && samplesize != 24 && samplesize != 32) {
+					PRINT_E ("Invalid sample size (%s). Sample size must be either 16, 24 or 32.\n", optarg);
+					::exit (EXIT_FAILURE);
+				}
+				break;
+
+			case 't':
+				template_path = template_path_from_name (optarg);
+				if (template_path.empty ()) {
+					cerr << "Invalid (non-existent) template:" << optarg << "\n";
+					::exit (EXIT_FAILURE);
+				}
+				break;
+
+			case 'p':
+				output_folder = string (optarg);
+				break;
+
+			case 'n':
+				session_name = string (optarg);
+				break;
+
+			case 'l':
+				media_location_path = string (optarg);
+				break;
+
+			case 'c':
+				media_cache_path = string (optarg);
+				break;
+
+			case 'k':
+				keep_cache = 1;
+				break;
+
+			case 'a':
+				aaf_file = string (optarg);
+				break;
+
+			case 0x01:
+				aaf_resolve_options |= RESOLVE_INCLUDE_DISABLED_CLIPS;
+				break;
+
+			case 0x02:
+				aaf_protools_options |= PROTOOLS_REMOVE_SAMPLE_ACCURATE_EDIT;
+				break;
+
+			case 0x03:
+				aaf_protools_options |= PROTOOLS_REPLACE_CLIP_FADES;
+				break;
+
+			default:
+				cerr << "Error: unrecognized option. See --help for usage information.\n";
+				::exit (EXIT_FAILURE);
+				break;
+		}
+	}
+
+	int missing_param = 0;
+
+	// if ( template_path.empty() )
+	// {
+	// 	PRINT_E( "Missing template. Use --template parameter.\n" );
+	//   missing_param = 1;
+	// }
+
+	if (output_folder.empty ()) {
+		PRINT_E ("Missing session path. Use --session-path parameter.\n");
+		missing_param = 1;
+	}
+
+	if (aaf_file.empty ()) {
+		PRINT_E ("Missing AAF file. Use --aaf parameter.\n");
+		missing_param = 1;
+	}
+
+	if (missing_param) {
+		::exit (EXIT_FAILURE);
+	}
+
+	AAF_Iface* aafi = aafi_alloc (NULL);
+
+	aafi->ctx.options.trace    = 1;
+	aafi->ctx.options.resolve  = aaf_resolve_options;
+	aafi->ctx.options.protools = aaf_protools_options;
+
+	/*
+	 * The following "forbid_nonlatin_filenames" option is there until we find a
+	 * solution to avoid issue with e.g korean filenames (e.g: pt-ko.aaf) :
+	 *
+	 * [e] ../session_utils/new_aaf_session.cc : main() on line 1279 : Could not import '샘플 단위 정밀 편집_2' to session.
+	 * : [ERROR]: FFMPEGFileImportableSource: Failed to read file metadata
+	 * : [ERROR]: Import: cannot open input sound file "/tmp/pt-ko/Ø
+	 *
+	 * NOTE: "Could not import '샘플 단위 정밀 편집_2' to session." prints korean chars well in console.
+	 */
+	aafi->ctx.options.forbid_nonlatin_filenames = 1;
+
+	/*
+	 * prepare libAAF log file.
+	 * using a file pointer avoids the need to reimplement debug_callback()
+	 */
+
+	string logfile = g_build_path (G_DIR_SEPARATOR_S, output_folder.c_str (), string (string (g_basename (aaf_file.c_str ())) + ".log").c_str (), NULL);
+
+	PRINT_I ("Writting AAF log to : %s\n", logfile.c_str ());
+
+	FILE* logfilefp = fopen (logfile.c_str (), "w");
+
+	if (logfilefp == NULL) {
+		PRINT_E ("Could not open log file '%s'\n", logfile.c_str ());
+		::exit (EXIT_FAILURE);
+	}
+
+	aafi_set_debug (aafi, VERB_DEBUG, logfilefp, NULL, NULL);
+
+	if (!media_location_path.empty ()) {
+		aafi_set_media_location (aafi, media_location_path.c_str ());
+	}
+
+	if (aafi_load_file (aafi, aaf_file.c_str ())) {
+		PRINT_E ("Could not load AAF file.\n");
+		::exit (EXIT_FAILURE);
+	}
+
+	if (prepare_cache (aafi, &media_cache_path)) {
+		PRINT_E ("Could not prepare media cache path.\n");
+		::exit (EXIT_FAILURE);
+	}
+
+	printf ("Media Cache : %s\n\n", media_cache_path.c_str ());
+
+	/*
+	 * At this stage, AFF was loaded and parsed,
+	 * so we can print a few things first.
+	 */
+
+	aaf_dump_Header (aafi->aafd);
+
+	aaf_dump_Identification (aafi->aafd);
+
+	printf (" Composition Name       : %ls\n", aafi->compositionName);
+	printf (" Composition Start      : %lu\n", eu2sample (aafi->Audio->samplerate, &aafi->compositionStart_editRate, aafi->compositionStart));
+	printf (" Composition End        : %lu\n", eu2sample (aafi->Audio->samplerate, &aafi->compositionLength_editRate, aafi->compositionLength) + eu2sample (aafi->Audio->samplerate, &aafi->compositionStart_editRate, aafi->compositionStart));
+	printf (" Composition SampleRate : %li Hz\n", aafi->Audio->samplerate);
+	printf (" Composition SampleSize : %i bits\n", aafi->Audio->samplesize);
+	printf ("\n");
+
+	if (!samplerate) {
+		PRINT_I ("Using AAF file sample rate : %li Hz\n", aafi->Audio->samplerate);
+		samplerate = aafi->Audio->samplerate;
+	} else {
+		PRINT_I ("Ignoring AAF file sample rate (%li Hz), using user defined : %i Hz\n", aafi->Audio->samplerate, samplerate);
+	}
+
+	aafRational_t samplerate_r;
+
+	samplerate_r.numerator   = samplerate;
+	samplerate_r.denominator = 1;
+
+	if (!samplesize) {
+		PRINT_I ("Using AAF file bit depth : %i bits\n", aafi->Audio->samplesize);
+		samplesize = aafi->Audio->samplesize;
+	} else {
+		PRINT_I ("Ignoring AAF file bit depth (%i bits), using user defined : %i bits\n", aafi->Audio->samplesize, samplesize);
+	}
+
+	switch (samplesize) {
+		case 16:
+			bitdepth = ARDOUR::FormatInt16;
+			break;
+		case 24:
+			bitdepth = ARDOUR::FormatInt24;
+			break;
+		case 32:
+			bitdepth = ARDOUR::FormatFloat;
+			break;
+		default:
+			PRINT_E ("Invalid sample size (%i). Sample size must be either 16, 24 or 32.\n", samplesize);
+			::exit (EXIT_FAILURE);
+	}
+
+	if (session_name.empty () && aafi->compositionName && aafi->compositionName[0] != 0x00) {
+		wstring ws_session_name = std::wstring (aafi->compositionName);
+		session_name            = string (ws_session_name.begin (), ws_session_name.end ());
+		PRINT_I ("Using AAF composition name for Ardour session name : %ls\n", aafi->compositionName);
+	} else if (session_name.empty () || session_name == "AAFFILE") {
+		/*
+		 * Code from gtk2_ardour/utils_videotl.cc
+		 * VideoUtils::strip_file_extension()
+		 */
+		std::string infile = Glib::path_get_basename (string (aafi->aafd->cfbd->file));
+		char *      ext, *bn = strdup (infile.c_str ());
+		if ((ext = strrchr (bn, '.'))) {
+			if (!strchr (ext, G_DIR_SEPARATOR)) {
+				*ext = 0;
+			}
+		}
+		session_name = std::string (bn);
+		free (bn);
+
+		if (session_name.empty ()) {
+			PRINT_I ("AAF has no composition name, using AAF file name for Ardour session name : %s\n", session_name.c_str ());
+		} else {
+			PRINT_I ("Force using AAF file name for Ardour session name : %s\n", session_name.c_str ());
+		}
+	}
+
+	laaf_util_clean_filename (&session_name[0]);
+
+	if (Glib::file_test (string (output_folder + G_DIR_SEPARATOR + session_name), Glib::FILE_TEST_IS_DIR)) {
+		PRINT_E ("Session folder already exists '%s'\n", string (output_folder + G_DIR_SEPARATOR + session_name).c_str ());
+		::exit (EXIT_FAILURE);
+	}
+
+	SessionUtils::init ();
+	Session* s = NULL;
+
+	try {
+		s = create_new_session (output_folder + G_DIR_SEPARATOR + session_name /*session_file*/, session_name, samplerate, bitdepth, master_bus_chn, template_path);
+	} catch (ARDOUR::SessionException& e) {
+		// cerr << "Error: " << e.what () << "\n";
+		PRINT_E ("Could not create ardour session : %s\n", e.what ());
+		SessionUtils::unload_session (s);
+		SessionUtils::cleanup ();
+		aafi_release (&aafi);
+		::exit (EXIT_FAILURE);
+	} catch (...) {
+		// cerr << "Error: unknown exception.\n";
+		PRINT_E ("Could not create ardour session.\n");
+		SessionUtils::unload_session (s);
+		SessionUtils::cleanup ();
+		aafi_release (&aafi);
+		::exit (EXIT_FAILURE);
+	}
+
+	/*
+	 *
+	 *  Extract audio files and import as sources
+	 *  libs/ardour/import_pt.cc#L188
+	 *
+	 */
+
+	SourceList                      oneClipSources;
+	ARDOUR::ImportStatus            import_status;
+	vector<std::shared_ptr<Region>> source_regions;
+	timepos_t                       pos = timepos_t::max (Temporal::AudioTime);
+
+	aafiAudioEssence* audioEssence = NULL;
+
+	foreachEssence (audioEssence, aafi->Audio->Essences)
+	{
+		/*
+		 *  If we extract embedded essences to `s->session_directory().sound_path()` then we end up with a duplicate on import.
+		 *  So we extract essence to a cache folder
+		 */
+
+		if (audioEssence->is_embedded) {
+			if (media_cache_path.empty ()) {
+				PRINT_E ("Could not extract audio file from AAF : media cache was not set.\n");
+				continue;
+			}
+			if (aafi_extract_audio_essence (aafi, audioEssence, media_cache_path.c_str (), NULL) < 0) {
+				PRINT_E ("Could not extract audio file '%ls' from AAF.\n", audioEssence->unique_file_name);
+				continue; // TODO or fail ?
+			}
+		} else {
+			if (!audioEssence->usable_file_path) {
+				PRINT_E ("Could not locate external audio file : '%ls'\n", audioEssence->original_file_path);
+				continue; // TODO or fail ?
+			}
+		}
+
+		if (!import_sndfile_as_region (s, audioEssence, SrcBest, pos, oneClipSources, import_status, &source_regions)) {
+			PRINT_E ("Could not import '%ls' to session.\n", audioEssence->unique_file_name);
+			continue; // TODO or fail ?
+		}
+
+		audioEssence->user = new SourceList (oneClipSources);
+
+		PRINT_I ("Source file '%ls' successfully imported to session.\n", audioEssence->unique_file_name);
+	}
+
+	oneClipSources.clear ();
+
+	/*
+	 *  Get timeline offset as sample value
+	 */
+	aafPosition_t sessionStart = convertEditUnit (aafi->compositionStart, aafi->compositionStart_editRate, samplerate_r);
+
+	/*
+	 *
+	 *  Create all audio clips
+	 *
+	 */
+
+	aafiAudioTrack*   aafAudioTrack = NULL;
+	aafiTimelineItem* aafAudioItem  = NULL;
+	aafiAudioClip*    aafAudioClip  = NULL;
+
+	foreach_audioTrack (aafAudioTrack, aafi)
+	{
+		std::shared_ptr<AudioTrack> track = prepare_audio_track (aafAudioTrack, s);
+
+		foreach_Item (aafAudioItem, aafAudioTrack)
+		{
+			if (aafAudioItem->type != AAFI_AUDIO_CLIP) {
+				continue;
+			}
+
+			aafAudioClip = (aafiAudioClip*)aafAudioItem->data;
+
+			if (aafAudioClip->Essence == NULL) {
+				PRINT_E ("AAF clip has no essence\n");
+				continue;
+			}
+
+			/* converts whatever edit_rate clip is in, to samples */
+			aafPosition_t clipPos = convertEditUnit (aafAudioClip->pos, *aafAudioClip->track->edit_rate, samplerate_r);
+
+			PRINT_I ("Importing new clip %ls [%+05.1lf dB] on track %i @%s\n",
+			         aafAudioClip->Essence->unique_file_name,
+			         ((aafAudioClip->gain && aafAudioClip->gain->flags & AAFI_AUDIO_GAIN_CONSTANT) ? 20 * log10 (aafRationalToFloat (aafAudioClip->gain->value[0])) : 0),
+			         aafAudioClip->track->number,
+			         timecode_format_sampletime ((clipPos + sessionStart), samplerate, aafi->Timecode->fps, false).c_str ());
+
+			aafiAudioEssence* audioEssence = aafAudioClip->Essence;
+
+			if (!audioEssence || !audioEssence->user) {
+				PRINT_E ("Could not create new region for clip %ls : Missing audio essence\n", aafAudioClip->Essence->unique_file_name);
+				continue;
+			}
+
+			SourceList* oneClipSources = static_cast<SourceList*> (audioEssence->user);
+
+			if (oneClipSources->size () == 0) {
+				PRINT_E ("Could not create new region for clip %ls : Region has no source\n", aafAudioClip->Essence->unique_file_name);
+				continue;
+			}
+
+			std::shared_ptr<Region> region = create_region (source_regions, aafAudioClip, *oneClipSources, sessionStart, samplerate_r);
+
+			if (!region) {
+				PRINT_E ("Could not create new region for clip %ls\n", aafAudioClip->Essence->unique_file_name);
+				::exit (EXIT_FAILURE);
+			}
+
+			/* Put region on track */
+
+			std::shared_ptr<Playlist> playlist = track->playlist ();
+
+			playlist->add_region (region, timepos_t (clipPos + sessionStart));
+
+			set_region_gain (aafAudioClip, region, s);
+
+			set_region_fade (aafAudioClip, region, &samplerate_r);
+
+			if (aafAudioClip->mute) {
+				region->set_muted (true);
+			}
+		}
+	}
+
+	aafiMarker* marker = NULL;
+
+	foreachMarker (marker, aafi)
+	{
+		aafPosition_t markerStart = sessionStart + convertEditUnit (marker->start, *marker->edit_rate, samplerate_r);
+		aafPosition_t markerEnd   = sessionStart + convertEditUnit ((marker->start + marker->length), *marker->edit_rate, samplerate_r);
+
+		wstring markerName (marker->name);
+
+		Location* location;
+
+		if (marker->length == 0) {
+			location = new Location (*s, timepos_t (markerStart), timepos_t (markerStart), string (markerName.begin (), markerName.end ()), Location::Flags (Location::IsMark));
+		} else {
+			location = new Location (*s, timepos_t (markerStart), timepos_t (markerEnd), string (markerName.begin (), markerName.end ()), Location::Flags (Location::IsRangeMarker));
+		}
+
+		s->locations ()->add (location, true);
+	}
+
+	set_session_range (s, aafi);
+
+	/* Import Video from AAF: SegFault ! */
+	// set_session_video_from_aaf( s, aafi );
+
+	set_session_timecode (s, aafi);
+
+	import_status.progress = 1.0;
+	import_status.done     = true;
+	s->save_state ("");
+	import_status.sources.clear ();
+	import_status.all_done = true;
+
+	/* clear */
+
+	foreachEssence (audioEssence, aafi->Audio->Essences)
+	{
+		if (audioEssence && audioEssence->user) {
+			static_cast<SourceList*> (audioEssence->user)->clear ();
+		}
+	}
+
+	source_regions.clear ();
+
+	if (!keep_cache) {
+		clear_cache (aafi, media_cache_path);
+	}
+
+	SessionUtils::unload_session (s);
+	SessionUtils::cleanup ();
+
+	aafi_release (&aafi);
+
+	fclose (logfilefp);
+
+	return 0;
+}
+
+// static void set_session_video_from_aaf( Session *s, AAF_Iface *aafi )
+// {
+//   if ( aafi->Video->Tracks && aafi->Video->Tracks->Items ) {
+//
+// 		aafiVideoClip *videoClip = (aafiVideoClip*)&aafi->Video->Tracks->Items->data;
+//
+// 		// printf( "\n\n\nGot video Track and Item : %ls\n\n\n", videoClip->Essence->original_file_path/*->Essence->original_file_path*/ );
+//     // char origf[PATH_MAX+1];
+//     // snprintf(origf, PATH_MAX, "%ls", videoClip->Essence->original_file_path ); // TODOPATH
+//     // printf("Looking for : %s\n", strrchr(origf, '/') + 1 );
+//
+// 		char *file = locate_external_essence_file( aafi, videoClip->Essence->original_file_path, NULL );
+//
+// 		if ( file != NULL ) {
+//       PRINT_I( "Importing video : %s\n", Glib::path_get_basename(string(file)).c_str()/*fop_get_filename(file)*/ );
+//
+// 			/* get absolute video file path */
+// 			std::string absFile (PBD::canonical_path (file));
+//
+// 			// /* get original mxf video filename */
+// 			// char *file_name = remove_file_ext( basename(file), '.', '/' );
+// 			//
+// 			// /* creates project video folder */
+// 			// mkdir( s->session_directory().video_path().c_str(), 0755 );
+// 			//
+// 			// /* extract mpeg video from original mxf */
+// 			// char cmdstr[PATH_MAX*6];
+// 			// snprintf( cmdstr, sizeof(cmdstr), "ffmpeg -y -i \"%s\" -c copy -f mpeg2video \"%s/%s.mpg\"", absFile, s->session_directory().video_path().c_str(), file_name );
+// 			// //snprintf( cmdstr, sizeof(cmdstr), "ffmpeg -y -i \"%s\" -c copy -map_metadata 0 \"%s/%s.mkv\"", absFile, s->session_directory().video_path().c_str(), file_name );
+// 			//
+// 			// system(cmdstr);
+//
+//
+// 			/* Add video to Ardour
+// 			 * ===================
+// 			 * https://github.com/Ardour/ardour/blob/6987196ea18cbf171e22ed62760962576ccb54da/gtk2_ardour/ardour_ui_video.cc#L317
+// 			 *
+// 			 *	<Videotimeline Filename="/home/agfline/Developpement/ardio/watchfolder/3572607_RUGBY_F2_S65CFA3D0V.mxf" AutoFPS="1" LocalFile="1" OriginalVideoFile="/home/agfline/Developpement/ardio/watchfolder/3572607_RUGBY_F2_S65CFA3D0V.mxf"/>
+//             <RulerVisibility timecode="1" bbt="1" samples="0" minsec="0" tempo="1" meter="1" marker="1" rangemarker="1" transportmarker="1" cdmarker="1" videotl="1"/>
+// 			 */
+//
+// 			XMLNode* videoTLnode = new XMLNode( "Videotimeline" );
+// 			videoTLnode->set_property( "Filename", absFile/*string(file_name) + ".mpg"*/ );
+// 			videoTLnode->set_property( "AutoFPS", true );
+// 			videoTLnode->set_property( "LocalFile", true );
+// 			videoTLnode->set_property( "OriginalVideoFile", string(absFile) );
+// 			videoTLnode->set_property( "id", 51 );
+// 			videoTLnode->set_property( "Height", 3 );
+// 			videoTLnode->set_property( "VideoOffsetLock", true );
+// 			videoTLnode->set_property( "VideoOffset", eu2sample( s->sample_rate(), videoClip->track->Video->tc->edit_rate, (videoClip->pos + videoClip->track->Video->tc->start)) );
+//
+//       // printf("\n\n\n%li  |  %li\n\n\n", videoClip->pos, videoClip->track->Video->tc->start );
+//
+// 			XMLNode* videoMONnode = new XMLNode( "Videomonitor" );
+// 			videoMONnode->set_property( "active", true );
+//
+//
+//
+// 			XMLNode* xjnode = new XMLNode( "XJSettings" );
+//
+//       XMLNode* xjsetting;
+//       xjsetting = xjnode->add_child( "XJSetting" );
+//       xjsetting->set_property( "k", "set offset" );
+//       xjsetting->set_property( "v", "-90000" ); //videoClip->pos * videoClip->track->Video->tc->edit_rate );
+//
+//       xjsetting = xjnode->add_child( "XJSetting" );
+//       xjsetting->set_property( "k", "osd smpte" );
+//       xjsetting->set_property( "v", "95" );
+//
+//       /* video_monitor.cc
+//       <XJSettings>
+//         <XJSetting k="window fullscreen" v="on"/>
+//         <XJSetting k="set offset" v="-90000"/>
+//         <XJSetting k="osd smpte" v="95"/>
+//       </XJSettings>
+//       */
+//
+// 			s->add_extra_xml(*xjnode);
+// 			s->add_extra_xml(*videoTLnode);
+// 			s->add_extra_xml(*videoMONnode);
+//
+// 			// s->set_dirty();
+// 		}
+//     else {
+//       PRINT_E( "Could not locate video file : %ls\n", videoClip->Essence->original_file_path );
+//     }
+// 	}
+//   else {
+//     PRINT_E( "Could not retrieve video from AAF.\n" );
+//   }
+// }
diff --git a/session_utils/wscript b/session_utils/wscript
index 509181f56c..b7f6ef2b19 100644
--- a/session_utils/wscript
+++ b/session_utils/wscript
@@ -44,6 +44,12 @@ def build_ardour_util(bld, util):
     obj.uselib       += ' AUDIOUNITS OSX LO '
     obj.uselib       += ' FFTW3F LO TAGLIB LILV RUBBERBAND AUBIO LRDF ARCHIVE VAMPSDK VAMPHOSTSDK'
 
+    if util == "new_aaf_session":
+        if bld.is_defined('USE_EXTERNAL_LIBS'):
+            obj.uselib += ' LIBAAF'
+        else:
+            obj.use.extend (['libaaf'])
+
     if bld.is_defined('HAVE_SUIL'):
         obj.uselib += ' SUIL'