X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fexport_profile_manager.cc;h=a86b2a7768388aee9266aaadc5c5c0761f0db842;hb=a473d630eb165272992e90f8d854b1d66ec0be63;hp=b5d85fcfa21bf1e916249d56b17503135935a374;hpb=5fa6ed1966d68b10041d7c563ef214ef33be0e88;p=ardour.git

diff --git a/libs/ardour/export_profile_manager.cc b/libs/ardour/export_profile_manager.cc
index b5d85fcfa2..a86b2a7768 100644
--- a/libs/ardour/export_profile_manager.cc
+++ b/libs/ardour/export_profile_manager.cc
@@ -18,68 +18,69 @@
 
 */
 
-#include <ardour/export_profile_manager.h>
-
 #include <cassert>
 #include <stdexcept>
 
 #include <glibmm/fileutils.h>
 
-#include <pbd/enumwriter.h>
-#include <pbd/xml++.h>
-#include <pbd/convert.h>
-
-#include <ardour/export_failed.h>
-#include <ardour/export_file_io.h>
-#include <ardour/export_format_specification.h>
-#include <ardour/export_timespan.h>
-#include <ardour/export_channel_configuration.h>
-#include <ardour/export_filename.h>
-#include <ardour/export_preset.h>
-#include <ardour/export_handler.h>
-#include <ardour/filename_extensions.h>
-#include <ardour/session.h>
+#include "pbd/enumwriter.h"
+#include "pbd/xml++.h"
+#include "pbd/convert.h"
+
+#include "ardour/export_profile_manager.h"
+#include "ardour/export_format_specification.h"
+#include "ardour/export_formats_search_path.h"
+#include "ardour/export_timespan.h"
+#include "ardour/export_channel_configuration.h"
+#include "ardour/export_filename.h"
+#include "ardour/export_preset.h"
+#include "ardour/export_handler.h"
+#include "ardour/export_failed.h"
+#include "ardour/filename_extensions.h"
+#include "ardour/route.h"
+#include "ardour/session.h"
+#include "ardour/broadcast_info.h"
 
 #include "i18n.h"
 
+using namespace std;
+using namespace Glib;
 using namespace PBD;
 
 namespace ARDOUR
 {
 
-ExportProfileManager::ExportProfileManager (Session & s) :
-  handler (s.get_export_handler()),
-  session (s),
+ExportProfileManager::ExportProfileManager (Session & s, std::string xml_node_name)
+  : xml_node_name (xml_node_name)
+  , handler (s.get_export_handler())
+  , session (s)
 
-  session_range (new Location ()),
-  ranges (new LocationList ()),
-  single_range_mode (false),
+  , session_range (new Location (s))
+  , ranges (new LocationList ())
+  , single_range_mode (false)
 
-  format_list (new FormatList ())
+  , format_list (new FormatList ())
 {
-
 	/* Initialize path variables */
 
 	export_config_dir = user_config_directory();
 	export_config_dir /= "export";
-	search_path += export_config_dir;
-	
-	search_path += ardour_search_path().add_subdirectory_to_paths("export");
-	search_path += system_config_search_path().add_subdirectory_to_paths("export");;
-	
-	std::cout << "search_path: " << search_path.to_string () << std::endl;
-	
+
+	search_path += export_formats_search_path();
+
+	info << string_compose (_("Searching for export formats in %1"), search_path.to_string()) << endmsg;
+
 	/* create export config directory if necessary */
 
 	if (!sys::exists (export_config_dir)) {
 		sys::create_directory (export_config_dir);
 	}
-	
+
 	load_presets ();
 	load_formats ();
-	
+
 	/* Initialize all lists with an empty config */
-	
+
 	XMLNodeList dummy;
 	init_timespans (dummy);
 	init_channel_configs (dummy);
@@ -90,8 +91,8 @@ ExportProfileManager::ExportProfileManager (Session & s) :
 ExportProfileManager::~ExportProfileManager ()
 {
 	if (single_range_mode) { return; }
-	
-	XMLNode * instant_xml (new XMLNode ("ExportProfile"));
+
+	XMLNode * instant_xml (new XMLNode (xml_node_name));
 	serialize_profile (*instant_xml);
 	session.add_instant_xml (*instant_xml, false);
 }
@@ -99,11 +100,11 @@ ExportProfileManager::~ExportProfileManager ()
 void
 ExportProfileManager::load_profile ()
 {
-	XMLNode * instant_node = session.instant_xml ("ExportProfile");
+	XMLNode * instant_node = session.instant_xml (xml_node_name);
 	if (instant_node) {
 		set_state (*instant_node);
 	} else {
-		XMLNode empty_node ("ExportProfile");
+		XMLNode empty_node (xml_node_name);
 		set_state (empty_node);
 	}
 }
@@ -111,19 +112,32 @@ ExportProfileManager::load_profile ()
 void
 ExportProfileManager::prepare_for_export ()
 {
-	ChannelConfigPtr channel_config = channel_configs.front()->config;
 	TimespanListPtr ts_list = timespans.front()->timespans;
-	
+
 	FormatStateList::const_iterator format_it;
 	FilenameStateList::const_iterator filename_it;
-	
+
+	// For each timespan
 	for (TimespanList::iterator ts_it = ts_list->begin(); ts_it != ts_list->end(); ++ts_it) {
+		// ..., each format-filename pair
 		for (format_it = formats.begin(), filename_it = filenames.begin();
 		     format_it != formats.end() && filename_it != filenames.end();
 		     ++format_it, ++filename_it) {
-		
+
+			FilenamePtr filename = (*filename_it)->filename;
 //			filename->include_timespan = (ts_list->size() > 1); Disabled for now...
-			handler->add_export_config (*ts_it, channel_config, (*format_it)->format, (*filename_it)->filename);
+
+			boost::shared_ptr<BroadcastInfo> b;
+			if ((*format_it)->format->has_broadcast_info()) {
+				b.reset (new BroadcastInfo);
+				b->set_from_session (session, (*ts_it)->get_start());
+			}
+
+			// ...and each channel config
+			filename->include_channel_config = (channel_configs.size() > 1);
+			for(ChannelConfigStateList::iterator cc_it = channel_configs.begin(); cc_it != channel_configs.end(); ++cc_it) {
+				handler->add_export_config (*ts_it, (*cc_it)->config, (*format_it)->format, filename, b);
+			}
 		}
 	}
 }
@@ -140,13 +154,13 @@ ExportProfileManager::load_preset (PresetPtr preset)
 	if ((state = preset->get_local_state())) {
 		set_local_state (*state);
 	} else { ok = false; }
-	
+
 	if ((state = preset->get_global_state())) {
 		if (!set_global_state (*state)) {
 			ok = false;
 		}
 	} else { ok = false; }
-	
+
 	return ok;
 }
 
@@ -160,15 +174,33 @@ ExportProfileManager::load_presets ()
 	}
 }
 
+std::string
+ExportProfileManager::preset_filename (std::string const & preset_name)
+{
+	string safe_name = legalize_for_path (preset_name);
+	return export_config_dir.to_string() + "/" + safe_name + export_preset_suffix;
+}
+
+ExportProfileManager::PresetPtr
+ExportProfileManager::new_preset (string const & name)
+{
+	// Generate new ID and do regular save
+	string filename = preset_filename (name);
+	current_preset.reset (new ExportPreset (filename, session));
+	preset_list.push_back (current_preset);
+	return save_preset (name);
+}
+
 ExportProfileManager::PresetPtr
 ExportProfileManager::save_preset (string const & name)
 {
+	string filename = preset_filename (name);
+
 	if (!current_preset) {
-		string filename = export_config_dir.to_string() + "/" + name + export_preset_suffix;
 		current_preset.reset (new ExportPreset (filename, session));
 		preset_list.push_back (current_preset);
 	}
-	
+
 	XMLNode * global_preset = new XMLNode ("ExportPreset");
 	XMLNode * local_preset = new XMLNode ("ExportPreset");
 
@@ -178,9 +210,9 @@ ExportProfileManager::save_preset (string const & name)
 	current_preset->set_name (name);
 	current_preset->set_global_state (*global_preset);
 	current_preset->set_local_state (*local_preset);
-	
-	current_preset->save();
-	
+
+	current_preset->save (filename);
+
 	return current_preset;
 }
 
@@ -201,7 +233,7 @@ ExportProfileManager::remove_preset ()
 		sys::remove (it->second);
 		preset_file_map.erase (it);
 	}
-	
+
 	current_preset->remove_local();
 	current_preset.reset();
 }
@@ -210,31 +242,32 @@ void
 ExportProfileManager::load_preset_from_disk (PBD::sys::path const & path)
 {
 	PresetPtr preset (new ExportPreset (path.to_string(), session));
-	preset_list.push_back (preset);
-	
-	/* Handle id to filename mapping */
-	
+
+	/* Handle id to filename mapping and don't add duplicates to list */
+
 	FilePair pair (preset->id(), path);
-	preset_file_map.insert (pair);
+	if (preset_file_map.insert (pair).second) {
+		preset_list.push_back (preset);
+	}
 }
 
 bool
 ExportProfileManager::set_state (XMLNode const & root)
 {
-	return set_global_state (root) && set_local_state (root);
+	return set_global_state (root) & set_local_state (root);
 }
 
 bool
 ExportProfileManager::set_global_state (XMLNode const & root)
 {
-	return init_filenames (root.children ("ExportFilename")) &&
+	return init_filenames (root.children ("ExportFilename")) &
 	       init_formats (root.children ("ExportFormat"));
 }
 
 bool
 ExportProfileManager::set_local_state (XMLNode const & root)
 {
-	return init_timespans (root.children ("ExportTimespan")) &&
+	return init_timespans (root.children ("ExportTimespan")) &
 	       init_channel_configs (root.children ("ExportChannelConfiguration"));
 }
 
@@ -263,7 +296,7 @@ ExportProfileManager::serialize_local_profile (XMLNode & root)
 	for (TimespanStateList::iterator it = timespans.begin(); it != timespans.end(); ++it) {
 		root.add_child_nocopy (serialize_timespan (*it));
 	}
-	
+
 	for (ChannelConfigStateList::iterator it = channel_configs.begin(); it != channel_configs.end(); ++it) {
 		root.add_child_nocopy ((*it)->config->get_state());
 	}
@@ -281,33 +314,33 @@ ExportProfileManager::find_file (std::string const & pattern)
 }
 
 void
-ExportProfileManager::set_selection_range (nframes_t start, nframes_t end)
+ExportProfileManager::set_selection_range (framepos_t start, framepos_t end)
 {
 
 	if (start || end) {
-		selection_range.reset (new Location());
+		selection_range.reset (new Location (session));
 		selection_range->set_name (_("Selection"));
 		selection_range->set (start, end);
 	} else {
 		selection_range.reset();
 	}
-	
+
 	for (TimespanStateList::iterator it = timespans.begin(); it != timespans.end(); ++it) {
 		(*it)->selection_range = selection_range;
 	}
 }
 
 std::string
-ExportProfileManager::set_single_range (nframes_t start, nframes_t end, Glib::ustring name)
+ExportProfileManager::set_single_range (framepos_t start, framepos_t end, string name)
 {
 	single_range_mode = true;
-	
-	single_range.reset (new Location());
+
+	single_range.reset (new Location (session));
 	single_range->set_name (name);
 	single_range->set (start, end);
-	
+
 	update_ranges ();
-	
+
 	return single_range->id().to_s();
 }
 
@@ -316,7 +349,7 @@ ExportProfileManager::init_timespans (XMLNodeList nodes)
 {
 	timespans.clear ();
 	update_ranges ();
-	
+
 	bool ok = true;
 	for (XMLNodeList::const_iterator it = nodes.begin(); it != nodes.end(); ++it) {
 		TimespanStatePtr span = deserialize_timespan (**it);
@@ -324,13 +357,20 @@ ExportProfileManager::init_timespans (XMLNodeList nodes)
 			timespans.push_back (span);
 		} else { ok = false; }
 	}
-	
+
 	if (timespans.empty()) {
-		TimespanStatePtr timespan (new TimespanState (session_range, selection_range, ranges));
-		timespans.push_back (timespan);
+		TimespanStatePtr state (new TimespanState (session_range, selection_range, ranges));
+		timespans.push_back (state);
+
+		// Add session as default selection
+		TimespanPtr timespan = handler->add_timespan();
+		timespan->set_name (session_range->name());
+		timespan->set_range_id ("session");
+		timespan->set_range (session_range->start(), session_range->end());
+		state->timespans->push_back (timespan);
 		return false;
 	}
-	
+
 	return ok;
 }
 
@@ -339,14 +379,14 @@ ExportProfileManager::deserialize_timespan (XMLNode & root)
 {
 	TimespanStatePtr state (new TimespanState (session_range, selection_range, ranges));
 	XMLProperty const * prop;
-	
+
 	XMLNodeList spans = root.children ("Range");
 	for (XMLNodeList::iterator node_it = spans.begin(); node_it != spans.end(); ++node_it) {
-		
+
 		prop = (*node_it)->property ("id");
 		if (!prop) { continue; }
-		ustring id = prop->value();
-	
+		string id = prop->value();
+
 		for (LocationList::iterator it = ranges->begin(); it != ranges->end(); ++it) {
 			if ((!id.compare ("session") && *it == session_range.get()) ||
 			    (!id.compare ("selection") && *it == selection_range.get()) ||
@@ -359,11 +399,11 @@ ExportProfileManager::deserialize_timespan (XMLNode & root)
 			}
 		}
 	}
-	
+
 	if ((prop = root.property ("format"))) {
 		state->time_format = (TimeFormat) string_2_enum (prop->value(), TimeFormat);
 	}
-	
+
 	return state;
 }
 
@@ -372,24 +412,24 @@ ExportProfileManager::serialize_timespan (TimespanStatePtr state)
 {
 	XMLNode & root = *(new XMLNode ("ExportTimespan"));
 	XMLNode * span;
-	
+
 	update_ranges ();
-	
+
 	for (TimespanList::iterator it = state->timespans->begin(); it != state->timespans->end(); ++it) {
 		if ((span = root.add_child ("Range"))) {
 			span->add_property ("id", (*it)->range_id());
 		}
 	}
-	
+
 	root.add_property ("format", enum_2_string (state->time_format));
-	
+
 	return root;
 }
 
 void
 ExportProfileManager::update_ranges () {
 	ranges->clear();
-	
+
 	if (single_range_mode) {
 		ranges->push_back (single_range.get());
 		return;
@@ -400,15 +440,15 @@ ExportProfileManager::update_ranges () {
 	session_range->set_name (_("Session"));
 	session_range->set (session.current_start_frame(), session.current_end_frame());
 	ranges->push_back (session_range.get());
-	
+
 	/* Selection */
-	
+
 	if (selection_range) {
 		ranges->push_back (selection_range.get());
 	}
-	
+
 	/* ranges */
-	
+
 	LocationList const & list (session.locations()->list());
 	for (LocationList::const_iterator it = list.begin(); it != list.end(); ++it) {
 		if ((*it)->is_range_marker()) {
@@ -417,23 +457,43 @@ ExportProfileManager::update_ranges () {
 	}
 }
 
+ExportProfileManager::ChannelConfigStatePtr
+ExportProfileManager::add_channel_config ()
+{
+	ChannelConfigStatePtr ptr(new ChannelConfigState(handler->add_channel_config()));
+	channel_configs.push_back(ptr);
+	return ptr;
+}
+
 bool
 ExportProfileManager::init_channel_configs (XMLNodeList nodes)
 {
 	channel_configs.clear();
 
-	if (nodes.empty()) {	
+	if (nodes.empty()) {
 		ChannelConfigStatePtr config (new ChannelConfigState (handler->add_channel_config()));
 		channel_configs.push_back (config);
+
+		// Add master outs as default
+		IO* master_out = session.master_out()->output().get();
+		if (!master_out) { return false; }
+
+		for (uint32_t n = 0; n < master_out->n_ports().n_audio(); ++n) {
+			PortExportChannel * channel = new PortExportChannel ();
+			channel->add_port (master_out->audio (n));
+
+			ExportChannelPtr chan_ptr (channel);
+			config->config->register_channel (chan_ptr);
+		}
 		return false;
 	}
-	
+
 	for (XMLNodeList::const_iterator it = nodes.begin(); it != nodes.end(); ++it) {
 		ChannelConfigStatePtr config (new ChannelConfigState (handler->add_channel_config()));
 		config->config->set_state (**it);
 		channel_configs.push_back (config);
 	}
-	
+
 	return true;
 }
 
@@ -466,48 +526,52 @@ ExportProfileManager::save_format_to_disk (FormatPtr format)
 
 	/* Get filename for file */
 
-	Glib::ustring new_name = format->name();
+	string new_name = format->name();
 	new_name += export_format_suffix;
-	
+
+        /* make sure its legal for the filesystem */
+
+        new_name = legalize_for_path (new_name);
+
 	sys::path new_path (export_config_dir);
 	new_path /= new_name;
 
 	/* Check if format is on disk already */
 	FileMap::iterator it;
 	if ((it = format_file_map.find (format->id())) != format_file_map.end()) {
-		
+
 		/* Check if config is not in user config dir */
 		if (it->second.branch_path().to_string().compare (export_config_dir.to_string())) {
-		
+
 			/* Write new file */
-		
+
 			XMLTree tree (new_path.to_string());
 			tree.set_root (&format->get_state());
 			tree.write();
-		
+
 		} else {
-		
+
 			/* Update file and rename if necessary */
-		
+
 			XMLTree tree (it->second.to_string());
 			tree.set_root (&format->get_state());
 			tree.write();
-			
+
 			if (new_name.compare (it->second.leaf())) {
 				sys::rename (it->second, new_path);
 			}
 		}
-		
+
 		it->second = new_path;
-		
+
 	} else {
 		/* Write new file */
-		
+
 		XMLTree tree (new_path.to_string());
 		tree.set_root (&format->get_state());
 		tree.write();
 	}
-	
+
 	FormatListChanged ();
 	return new_path;
 }
@@ -527,13 +591,13 @@ ExportProfileManager::remove_format_profile (FormatPtr format)
 		sys::remove (it->second);
 		format_file_map.erase (it);
 	}
-	
+
 	FormatListChanged ();
 }
 
 ExportProfileManager::FormatPtr
 ExportProfileManager::get_new_format (FormatPtr original)
-{	
+{
 	FormatPtr format;
 	if (original) {
 		format.reset (new ExportFormatSpecification (*original));
@@ -541,14 +605,14 @@ ExportProfileManager::get_new_format (FormatPtr original)
 		format = handler->add_format();
 		format->set_name ("empty format");
 	}
-	
+
 	sys::path path = save_format_to_disk (format);
 	FilePair pair (format->id(), path);
 	format_file_map.insert (pair);
-	
+
 	format_list->push_back (format);
 	FormatListChanged ();
-	
+
 	return format;
 }
 
@@ -564,13 +628,13 @@ ExportProfileManager::init_formats (XMLNodeList nodes)
 			formats.push_back (format);
 		} else { ok = false; }
 	}
-	
+
 	if (formats.empty ()) {
 		FormatStatePtr format (new FormatState (format_list, FormatPtr ()));
 		formats.push_back (format);
 		return false;
 	}
-	
+
 	return ok;
 }
 
@@ -579,11 +643,11 @@ ExportProfileManager::deserialize_format (XMLNode & root)
 {
 	XMLProperty * prop;
 	UUID id;
-	
+
 	if ((prop = root.property ("id"))) {
 		id = prop->value();
 	}
-	
+
 	for (FormatList::iterator it = format_list->begin(); it != format_list->end(); ++it) {
 		if ((*it)->id() == id) {
 			return FormatStatePtr (new FormatState (format_list, *it));
@@ -597,10 +661,10 @@ XMLNode &
 ExportProfileManager::serialize_format (FormatStatePtr state)
 {
 	XMLNode * root = new XMLNode ("ExportFormat");
-	
+
 	string id = state->format ? state->format->id().to_s() : "";
 	root->add_property ("id", id);
-	
+
 	return *root;
 }
 
@@ -619,14 +683,14 @@ ExportProfileManager::load_format_from_disk (PBD::sys::path const & path)
 {
 	XMLTree const tree (path.to_string());
 	FormatPtr format = handler->add_format (*tree.root());
-	
+
 	/* Handle id to filename mapping and don't add duplicates to list */
-	
+
 	FilePair pair (format->id(), path);
 	if (format_file_map.insert (pair).second) {
 		format_list->push_back (format);
 	}
-	
+
 	FormatListChanged ();
 }
 
@@ -659,13 +723,13 @@ ExportProfileManager::init_filenames (XMLNodeList nodes)
 		filename->set_state (**it);
 		filenames.push_back (FilenameStatePtr (new FilenameState (filename)));
 	}
-	
+
 	if (filenames.empty()) {
 		FilenameStatePtr filename (new FilenameState (handler->add_filename()));
 		filenames.push_back (filename);
 		return false;
 	}
-	
+
 	return true;
 }
 
@@ -674,28 +738,30 @@ ExportProfileManager::get_warnings ()
 {
 	boost::shared_ptr<Warnings> warnings (new Warnings ());
 
+	assert (!channel_configs.empty ());
+
 	ChannelConfigStatePtr channel_config_state = channel_configs.front();
 	TimespanStatePtr timespan_state = timespans.front();
-	
+
 	/*** Check "global" config ***/
-	
+
 	TimespanListPtr timespans = timespan_state->timespans;
 	ChannelConfigPtr channel_config = channel_config_state->config;
 
 	/* Check Timespans are not empty */
-	
+
 	if (timespans->empty()) {
 		warnings->errors.push_back (_("No timespan has been selected!"));
 	}
 
 	/* Check channel config ports */
-	
+
 	if (!channel_config->all_channels_have_ports ()) {
 		warnings->warnings.push_back (_("Some channels are empty"));
 	}
-	
+
 	/*** Check files ***/
-	
+
 	FormatStateList::const_iterator format_it;
 	FilenameStateList::const_iterator filename_it;
 	for (format_it = formats.begin(), filename_it = filenames.begin();
@@ -703,7 +769,7 @@ ExportProfileManager::get_warnings ()
 	     ++format_it, ++filename_it) {
 			check_config (warnings, timespan_state, channel_config_state, *format_it, *filename_it);
 	}
-	
+
 	return warnings;
 }
 
@@ -722,7 +788,9 @@ ExportProfileManager::check_config (boost::shared_ptr<Warnings> warnings,
 	/* Check format and maximum channel count */
 	if (!format || !format->type()) {
 		warnings->errors.push_back (_("No format selected!"));
-	} else if (!ExportFileFactory::check (format, channel_config->get_n_chans())) {
+	} else if (!channel_config->get_n_chans()) {
+		warnings->errors.push_back (_("All channels are empty!"));
+	} else if (!check_format (format, channel_config->get_n_chans())) {
 		warnings->errors.push_back (_("One or more of the selected formats is not compatible with this system!"));
 	} else if (format->channel_limit() < channel_config->get_n_chans()) {
 		warnings->errors.push_back
@@ -731,32 +799,32 @@ ExportProfileManager::check_config (boost::shared_ptr<Warnings> warnings,
 		                     format->channel_limit(),
 		                     channel_config->get_n_chans()));
 	}
-	
+
 	if (!warnings->errors.empty()) { return; }
-	
+
 	/* Check filenames */
-	
+
 //	filename->include_timespan = (timespans->size() > 1); Disabled for now...
-	
+
 	for (std::list<TimespanPtr>::iterator timespan_it = timespans->begin(); timespan_it != timespans->end(); ++timespan_it) {
 		filename->set_timespan (*timespan_it);
-	
+
 		if (channel_config->get_split()) {
 			filename->include_channel = true;
-			
+
 			for (uint32_t chan = 1; chan <= channel_config->get_n_chans(); ++chan) {
 				filename->set_channel (chan);
-				
-				Glib::ustring path = filename->get_path (format);
-				
+
+				string path = filename->get_path (format);
+
 				if (sys::exists (sys::path (path))) {
 					warnings->conflicting_filenames.push_back (path);
 				}
 			}
-			
+
 		} else {
-			Glib::ustring path = filename->get_path (format);
-			
+			string path = filename->get_path (format);
+
 			if (sys::exists (sys::path (path))) {
 				warnings->conflicting_filenames.push_back (path);
 			}
@@ -764,4 +832,27 @@ ExportProfileManager::check_config (boost::shared_ptr<Warnings> warnings,
 	}
 }
 
+bool
+ExportProfileManager::check_format (FormatPtr format, uint32_t channels)
+{
+	switch (format->type()) {
+	  case ExportFormatBase::T_Sndfile:
+		return check_sndfile_format (format, channels);
+
+	  default:
+		throw ExportFailed (X_("Invalid format given for ExportFileFactory::check!"));
+	}
+}
+
+bool
+ExportProfileManager::check_sndfile_format (FormatPtr format, unsigned int channels)
+{
+	SF_INFO sf_info;
+	sf_info.channels = channels;
+	sf_info.samplerate = format->sample_rate ();
+	sf_info.format = format->format_id () | format->sample_format ();
+
+	return (sf_format_check (&sf_info) == SF_TRUE ? true : false);
+}
+
 }; // namespace ARDOUR