X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Futils.cc;h=bda719780dba1c05f0eb20a422aa948df1f49a06;hb=63e3f326e9f61498a03a62a57d2e0787c19bf5c9;hp=904750e9d8eb700e0557e9104bda4a89893ffb8f;hpb=bce3184ff5383f47675a97a8184f7739552cb04e;p=ardour.git diff --git a/libs/ardour/utils.cc b/libs/ardour/utils.cc index 904750e9d8..bda719780d 100644 --- a/libs/ardour/utils.cc +++ b/libs/ardour/utils.cc @@ -36,7 +36,9 @@ #include #include #include +#ifndef COMPILER_MSVC #include +#endif #include #include @@ -60,12 +62,15 @@ using namespace ARDOUR; using namespace std; using namespace PBD; -string -legalize_for_path (const string& str) +static string +replace_chars (const string& str, const string& illegal_chars) { string::size_type pos; - string illegal_chars = "/\\"; /* DOS, POSIX. Yes, we're going to ignore HFS */ - string legal; + Glib::ustring legal; + + /* this is the one place in Ardour where we need to iterate across + * potential multibyte characters, and thus we need Glib::ustring + */ legal = str; pos = 0; @@ -77,9 +82,80 @@ legalize_for_path (const string& str) return string (legal); } +/** take an arbitrary string as an argument, and return a version of it + * suitable for use as a path (directory/folder name). This is the Ardour 3.X + * and later version of this code. It defines a very small number of characters + * that are not allowed in a path on the build target filesystem (basically, + * POSIX or Windows) and replaces any instances of them with an underscore. + * + * NOTE: this is intended only to legalize for the filesystem that Ardour + * is running on. Export should use legalize_for_universal_path() since + * the goal there is to be legal across filesystems. + */ +string +ARDOUR::legalize_for_path (const string& str) +{ + return replace_chars (str, "/\\"); +} + +/** take an arbitrary string as an argument, and return a version of it + * suitable for use as a path (directory/folder name). This is the Ardour 3.X + * and later version of this code. It defines a small number + * of characters that are not allowed in a path on any of our target + * filesystems, and replaces any instances of them with an underscore. + * + * NOTE: this is intended to create paths that should be legal on + * ANY filesystem. + */ +string +ARDOUR::legalize_for_universal_path (const string& str) +{ + return replace_chars (str, "<>:\"/\\|?*"); +} + +/** Legalize for a URI path component. This is like + * legalize_for_universal_path, but stricter, disallowing spaces and hash. + * This avoids %20 escapes in URIs, but probably needs work to be more strictly + * correct. + */ +string +ARDOUR::legalize_for_uri (const string& str) +{ + return replace_chars (str, "<>:\"/\\|?* #"); +} + +/** take an arbitrary string as an argument, and return a version of it + * suitable for use as a path (directory/folder name). This is the Ardour 2.X + * version of this code, which used an approach that came to be seen as + * problematic: defining the characters that were allowed and replacing all + * others with underscores. See legalize_for_path() for the 3.X and later + * version. + */ + +string +ARDOUR::legalize_for_path_2X (const string& str) +{ + string::size_type pos; + string legal_chars = "abcdefghijklmnopqrtsuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_+=: "; + Glib::ustring legal; + + /* this is the one place in Ardour where we need to iterate across + * potential multibyte characters, and thus we need Glib::ustring + */ + + legal = str; + pos = 0; + + while ((pos = legal.find_first_not_of (legal_chars, pos)) != string::npos) { + legal.replace (pos, 1, "_"); + pos += 1; + } + + return string (legal); +} string -bump_name_once (const std::string& name, char delimiter) +ARDOUR::bump_name_once (const std::string& name, char delimiter) { string::size_type delim; string newname; @@ -120,8 +196,34 @@ bump_name_once (const std::string& name, char delimiter) } +string +ARDOUR::bump_name_number (const std::string& name) +{ + size_t pos = name.length(); + size_t num = 0; + bool have_number = false; + while (pos > 0 && isdigit(name.at(--pos))) { + have_number = true; + num = pos; + } + + string newname; + if (have_number) { + int32_t seq = strtol (name.c_str() + num, (char **)NULL, 10); + char buf[32]; + snprintf (buf, sizeof(buf), "%d", seq + 1); + newname = name.substr (0, num); + newname += buf; + } else { + newname = name; + newname += "1"; + } + + return newname; +} + XMLNode * -find_named_node (const XMLNode& node, string name) +ARDOUR::find_named_node (const XMLNode& node, string name) { XMLNodeList nlist; XMLNodeConstIterator niter; @@ -142,7 +244,7 @@ find_named_node (const XMLNode& node, string name) } int -cmp_nocase (const string& s, const string& s2) +ARDOUR::cmp_nocase (const string& s, const string& s2) { string::const_iterator p = s.begin(); string::const_iterator p2 = s2.begin(); @@ -159,18 +261,43 @@ cmp_nocase (const string& s, const string& s2) } int -touch_file (string path) +ARDOUR::cmp_nocase_utf8 (const string& s1, const string& s2) { - int fd = open (path.c_str(), O_RDWR|O_CREAT, 0660); - if (fd >= 0) { - close (fd); - return 0; + const char *cstr1 = s1.c_str(); + const char *cstr2 = s2.c_str(); + gchar *cstr1folded = NULL; + gchar *cstr2folded = NULL; + int retval; + + if (!g_utf8_validate (cstr1, -1, NULL) || + !g_utf8_validate (cstr2, -1, NULL)) { + // fall back to comparing ASCII + return g_ascii_strcasecmp (cstr1, cstr2); } - return 1; + + cstr1folded = g_utf8_casefold (cstr1, -1); + cstr2folded = g_utf8_casefold (cstr2, -1); + + if (cstr1folded && cstr2folded) { + retval = strcmp (cstr1folded, cstr2folded); + } else { + // this shouldn't happen, make the best of it + retval = g_ascii_strcasecmp (cstr1, cstr2); + } + + if (cstr1folded) { + g_free (cstr1folded); + } + + if (cstr2folded) { + g_free (cstr2folded); + } + + return retval; } string -region_name_from_path (string path, bool strip_channels, bool add_channel_suffix, uint32_t total, uint32_t this_one) +ARDOUR::region_name_from_path (string path, bool strip_channels, bool add_channel_suffix, uint32_t total, uint32_t this_one) { path = PBD::basename_nosuffix (path); @@ -202,7 +329,7 @@ region_name_from_path (string path, bool strip_channels, bool add_channel_suffix } bool -path_is_paired (string path, string& pair_base) +ARDOUR::path_is_paired (string path, string& pair_base) { string::size_type pos; @@ -233,115 +360,9 @@ path_is_paired (string path, string& pair_base) return false; } -string -path_expand (string path) -{ - if (path.empty()) { - return path; - } - - /* tilde expansion */ - - if (path[0] == '~') { - if (path.length() == 1) { - return Glib::get_home_dir(); - } - - if (path[1] == '/') { - path.replace (0, 1, Glib::get_home_dir()); - } else { - /* can't handle ~roger, so just leave it */ - } - } - - /* now do $VAR substitution, since wordexp isn't reliable */ - - regex_t compiled_pattern; - const int nmatches = 100; - regmatch_t matches[nmatches]; - - if (regcomp (&compiled_pattern, "\\$([a-zA-Z_][a-zA-Z0-9_]*|\\{[a-zA-Z_][a-zA-Z0-9_]*\\})", REG_EXTENDED)) { - cerr << "bad regcomp\n"; - return path; - } - - while (true) { - - if (regexec (&compiled_pattern, path.c_str(), nmatches, matches, 0)) { - break; - } - - /* matches[0] gives the entire match */ - - string match = path.substr (matches[0].rm_so, matches[0].rm_eo - matches[0].rm_so); - - /* try to get match from the environment */ - - if (match[1] == '{') { - /* ${FOO} form */ - match = match.substr (2, match.length() - 3); - } - - char* matched_value = getenv (match.c_str()); - - if (matched_value) { - path.replace (matches[0].rm_so, matches[0].rm_eo - matches[0].rm_so, matched_value); - } else { - path.replace (matches[0].rm_so, matches[0].rm_eo - matches[0].rm_so, string()); - } - - /* go back and do it again with whatever remains after the - * substitution - */ - } - - regfree (&compiled_pattern); - - /* canonicalize */ - - char buf[PATH_MAX+1]; - - if (realpath (path.c_str(), buf)) { - return buf; - } else { - return string(); - } -} - -string -search_path_expand (string path) -{ - if (path.empty()) { - return path; - } - - vector s; - vector n; - - split (path, s, ':'); - - for (vector::iterator i = s.begin(); i != s.end(); ++i) { - string exp = path_expand (*i); - if (!exp.empty()) { - n.push_back (exp); - } - } - - string r; - - for (vector::iterator i = n.begin(); i != n.end(); ++i) { - if (!r.empty()) { - r += ':'; - } - r += *i; - } - - return r; -} - #if __APPLE__ string -CFStringRefToStdString(CFStringRef stringRef) +ARDOUR::CFStringRefToStdString(CFStringRef stringRef) { CFIndex size = CFStringGetMaximumSizeForEncoding(CFStringGetLength(stringRef) , @@ -359,7 +380,7 @@ CFStringRefToStdString(CFStringRef stringRef) #endif // __APPLE__ void -compute_equal_power_fades (framecnt_t nframes, float* in, float* out) +ARDOUR::compute_equal_power_fades (framecnt_t nframes, float* in, float* out) { double step; @@ -385,22 +406,24 @@ compute_equal_power_fades (framecnt_t nframes, float* in, float* out) } EditMode -string_to_edit_mode (string str) +ARDOUR::string_to_edit_mode (string str) { if (str == _("Splice")) { return Splice; } else if (str == _("Slide")) { return Slide; + } else if (str == _("Ripple")) { + return Ripple; } else if (str == _("Lock")) { return Lock; } fatal << string_compose (_("programming error: unknown edit mode string \"%1\""), str) << endmsg; - /*NOTREACHED*/ + abort(); /*NOTREACHED*/ return Slide; } const char* -edit_mode_to_string (EditMode mode) +ARDOUR::edit_mode_to_string (EditMode mode) { switch (mode) { case Slide: @@ -409,6 +432,9 @@ edit_mode_to_string (EditMode mode) case Lock: return _("Lock"); + case Ripple: + return _("Ripple"); + default: case Splice: return _("Splice"); @@ -416,7 +442,7 @@ edit_mode_to_string (EditMode mode) } SyncSource -string_to_sync_source (string str) +ARDOUR::string_to_sync_source (string str) { if (str == _("MIDI Timecode") || str == _("MTC")) { return MTC; @@ -427,20 +453,27 @@ string_to_sync_source (string str) } if (str == _("JACK")) { - return JACK; + return Engine; + } + + if (str == _("LTC")) { + return LTC; } fatal << string_compose (_("programming error: unknown sync source string \"%1\""), str) << endmsg; - /*NOTREACHED*/ - return JACK; + abort(); /*NOTREACHED*/ + return Engine; } /** @param sh Return a short version of the string */ const char* -sync_source_to_string (SyncSource src, bool sh) +ARDOUR::sync_source_to_string (SyncSource src, bool sh) { switch (src) { - case JACK: + case Engine: + /* no other backends offer sync for now ... deal with this if we + * ever have to. + */ return _("JACK"); case MTC: @@ -451,7 +484,11 @@ sync_source_to_string (SyncSource src, bool sh) } case MIDIClock: - return _("MIDI Clock"); + if (sh) { + return _("M-Clock"); + } else { + return _("MIDI Clock"); + } case LTC: return _("LTC"); @@ -461,7 +498,7 @@ sync_source_to_string (SyncSource src, bool sh) } float -meter_falloff_to_float (MeterFalloff falloff) +ARDOUR::meter_falloff_to_float (MeterFalloff falloff) { switch (falloff) { case MeterFalloffOff: @@ -470,21 +507,22 @@ meter_falloff_to_float (MeterFalloff falloff) return METER_FALLOFF_SLOWEST; case MeterFalloffSlow: return METER_FALLOFF_SLOW; + case MeterFalloffSlowish: + return METER_FALLOFF_SLOWISH; case MeterFalloffMedium: return METER_FALLOFF_MEDIUM; + case MeterFalloffModerate: + return METER_FALLOFF_MODERATE; case MeterFalloffFast: - return METER_FALLOFF_FAST; - case MeterFalloffFaster: - return METER_FALLOFF_FASTER; + case MeterFalloffFaster: // backwards compat enum MeterFalloff case MeterFalloffFastest: - return METER_FALLOFF_FASTEST; default: return METER_FALLOFF_FAST; } } MeterFalloff -meter_falloff_from_float (float val) +ARDOUR::meter_falloff_from_float (float val) { if (val == METER_FALLOFF_OFF) { return MeterFalloffOff; @@ -495,17 +533,17 @@ meter_falloff_from_float (float val) else if (val <= METER_FALLOFF_SLOW) { return MeterFalloffSlow; } - else if (val <= METER_FALLOFF_MEDIUM) { - return MeterFalloffMedium; + else if (val <= METER_FALLOFF_SLOWISH) { + return MeterFalloffSlowish; } - else if (val <= METER_FALLOFF_FAST) { - return MeterFalloffFast; + else if (val <= METER_FALLOFF_MODERATE) { + return MeterFalloffModerate; } - else if (val <= METER_FALLOFF_FASTER) { - return MeterFalloffFaster; + else if (val <= METER_FALLOFF_MEDIUM) { + return MeterFalloffMedium; } else { - return MeterFalloffFastest; + return MeterFalloffFast; } } @@ -523,7 +561,7 @@ ARDOUR::string_to_auto_state (std::string str) } fatal << string_compose (_("programming error: %1 %2"), "illegal AutoState string: ", str) << endmsg; - /*NOTREACHED*/ + abort(); /*NOTREACHED*/ return Touch; } @@ -547,7 +585,7 @@ ARDOUR::auto_state_to_string (AutoState as) } fatal << string_compose (_("programming error: %1 %2"), "illegal AutoState type: ", as) << endmsg; - /*NOTREACHED*/ + abort(); /*NOTREACHED*/ return ""; } @@ -561,7 +599,7 @@ ARDOUR::string_to_auto_style (std::string str) } fatal << string_compose (_("programming error: %1 %2"), "illegal AutoStyle string: ", str) << endmsg; - /*NOTREACHED*/ + abort(); /*NOTREACHED*/ return Trim; } @@ -580,7 +618,7 @@ ARDOUR::auto_style_to_string (AutoStyle as) } fatal << string_compose (_("programming error: %1 %2"), "illegal AutoStyle type: ", as) << endmsg; - /*NOTREACHED*/ + abort(); /*NOTREACHED*/ return ""; } @@ -591,7 +629,7 @@ bool_as_string (bool yn) } const char* -native_header_format_extension (HeaderFormat hf, const DataType& type) +ARDOUR::native_header_format_extension (HeaderFormat hf, const DataType& type) { if (type == DataType::MIDI) { return ".mid"; @@ -615,12 +653,12 @@ native_header_format_extension (HeaderFormat hf, const DataType& type) } fatal << string_compose (_("programming error: unknown native header format: %1"), hf); - /*NOTREACHED*/ + abort(); /*NOTREACHED*/ return ".wav"; } bool -matching_unsuffixed_filename_exists_in (const string& dir, const string& path) +ARDOUR::matching_unsuffixed_filename_exists_in (const string& dir, const string& path) { string bws = basename_nosuffix (path); struct dirent* dentry; @@ -665,7 +703,7 @@ matching_unsuffixed_filename_exists_in (const string& dir, const string& path) } uint32_t -how_many_dsp_threads () +ARDOUR::how_many_dsp_threads () { /* CALLER MUST HOLD PROCESS LOCK */ @@ -698,12 +736,14 @@ how_many_dsp_threads () return num_threads; } -double gain_to_slider_position_with_max (double g, double max_gain) +double +ARDOUR::gain_to_slider_position_with_max (double g, double max_gain) { return gain_to_slider_position (g * 2.0/max_gain); } -double slider_position_to_gain_with_max (double g, double max_gain) +double +ARDOUR::slider_position_to_gain_with_max (double g, double max_gain) { return slider_position_to_gain (g * max_gain/2.0); }