trunk/src/qsamplerUtilities.cpp

// qsamplerUtilities.cpp
//
/****************************************************************************
   Copyright (C) 2004-2007, rncbc aka Rui Nuno Capela. All rights reserved.
   Copyright (C) 2007, 2008 Christian Schoenebeck

   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 "qsamplerUtilities.h"

#include "qsamplerOptions.h"
#include "qsamplerMainForm.h"

#include <QRegExp>


using namespace QSampler;

namespace qsamplerUtilities {

static int _hexToNumber(char hex_digit) {
    switch (hex_digit) {
        case '0': return 0;
        case '1': return 1;
        case '2': return 2;
        case '3': return 3;
        case '4': return 4;
        case '5': return 5;
        case '6': return 6;
        case '7': return 7;
        case '8': return 8;
        case '9': return 9;

        case 'a': return 10;
        case 'b': return 11;
        case 'c': return 12;
        case 'd': return 13;
        case 'e': return 14;
        case 'f': return 15;

        case 'A': return 10;
        case 'B': return 11;
        case 'C': return 12;
        case 'D': return 13;
        case 'E': return 14;
        case 'F': return 15;

        default:  return 0;
    }
}

static int _hexsToNumber(char hex_digit0, char hex_digit1) {
    return _hexToNumber(hex_digit1)*16 + _hexToNumber(hex_digit0);
}

// returns true if the connected LSCP server supports escape sequences
static bool _remoteSupportsEscapeSequences() {
    const lscpVersion_t version = getRemoteLscpVersion();
    // LSCP v1.2 or younger required
    return (version.major > 1 || (version.major == 1 && version.minor >= 2));
}

// converts the given file path into a path as expected by LSCP 1.2
QString lscpEscapePath ( const QString& sPath )
{
    if (!_remoteSupportsEscapeSequences()) return sPath;

    QString path(sPath);

    // replace POSIX path escape sequences (%HH) by LSCP escape sequences (\xHH)
    // TODO: missing code for other systems like Windows
    {
        QRegExp regexp("%[0-9a-fA-F][0-9a-fA-F]");
        for (int i = path.indexOf(regexp); i >= 0; i = path.indexOf(regexp, i + 4))
            path.replace(i, 1, "\\x");
    }
    // replace POSIX path escape sequence (%%) by its raw character
    for (int i = path.indexOf("%%"); i >= 0; i = path.indexOf("%%", ++i))
        path.remove(i, 1);

    // replace all non-basic characters by LSCP escape sequences
    {
        const char pathSeparator = '/';
        QRegExp regexp(QRegExp::escape("\\x") + "[0-9a-fA-F][0-9a-fA-F]");
        for (int i = 0; i < int(path.length()); i++) {
            // first skip all previously added LSCP escape sequences
            if (path.indexOf(regexp, i) == i) {
                i += 3;
                continue;
            }
            // now match all non-alphanumerics
            // (we could exclude much more characters here, but that way
            // we're sure it just works^TM)
            const char c = path.at(i).toLatin1();
            if (
                !(c >= '0' && c <= '9') &&
                !(c >= 'a' && c <= 'z') &&
                !(c >= 'A' && c <= 'Z') &&
                #if defined(WIN32)
                !(c == ':') &&
                #endif
                !(c == pathSeparator)
            ) {
                // convert the non-basic character into a LSCP escape sequence
                char buf[5];
                ::snprintf(buf, sizeof(buf), "\\x%02x", static_cast<unsigned char>(c));
                path.replace(i, 1, buf);
                i += 3;
            }
        }
    }

    return path;
}

// converts a path returned by a LSCP command (and may contain escape
// sequences) into the appropriate POSIX path
QString lscpEscapedPathToPosix(QString path) {
    if (!_remoteSupportsEscapeSequences()) return path;

    // first escape all percent ('%') characters for POSIX
    for (int i = path.indexOf('%'); i >= 0; i = path.indexOf('%', i+2))
        path.replace(i, 1, "%%");

    // resolve LSCP hex escape sequences (\xHH)
    QRegExp regexp(QRegExp::escape("\\x") + "[0-9a-fA-F][0-9a-fA-F]");
    for (int i = path.indexOf(regexp); i >= 0; i = path.indexOf(regexp, i + 4)) {
        const QString sHex = path.mid(i+2, 2).toLower();
        // the slash has to be escaped for POSIX as well
        if (sHex == "2f") {
            path.replace(i, 4, "%2f");
            continue;
        }
        // all other characters we simply decode
        char cAscii = _hexsToNumber(sHex.at(1).toLatin1(), sHex.at(0).toLatin1());
        path.replace(i, 4, cAscii);
    }

    return path;
}

// converts the given text as expected by LSCP 1.2
// (that is by encoding special characters with LSCP escape sequences)
QString lscpEscapeText(const QString& txt) {
    if (!_remoteSupportsEscapeSequences()) return txt;

    QString text(txt);

    // replace all non-basic characters by LSCP escape sequences
    for (int i = 0; i < int(text.length()); ++i) {
        // match all non-alphanumerics
        // (we could exclude much more characters here, but that way
        // we're sure it just works^TM)
        const char c = text.at(i).toLatin1();
        if (
            !(c >= '0' && c <= '9') &&
            !(c >= 'a' && c <= 'z') &&
            !(c >= 'A' && c <= 'Z')
        ) {
            // convert the non-basic character into a LSCP escape sequence
            char buf[5];
            ::snprintf(buf, sizeof(buf), "\\x%02x", static_cast<unsigned char>(c));
            text.replace(i, 1, buf);
            i += 3;
        }
    }

    return text;
}

// converts a text returned by a LSCP command and may contain escape
// sequences) into raw text, that is with all escape sequences decoded
QString lscpEscapedTextToRaw(QString txt) {
    if (!_remoteSupportsEscapeSequences()) return txt;

    // resolve LSCP hex escape sequences (\xHH)
    QRegExp regexp(QRegExp::escape("\\x") + "[0-9a-fA-F][0-9a-fA-F]");
    for (int i = txt.indexOf(regexp); i >= 0; i = txt.indexOf(regexp, i + 4)) {
        const QString sHex = txt.mid(i+2, 2).toLower();
        // decode into raw ASCII character
        char cAscii = _hexsToNumber(sHex.at(1).toLatin1(), sHex.at(0).toLatin1());
        txt.replace(i, 4, cAscii);
    }

    return txt;
}

lscpVersion_t getRemoteLscpVersion (void)
{
    lscpVersion_t result = { 0, 0 };

    MainForm* pMainForm = MainForm::getInstance();
    if (pMainForm == NULL)
        return result;
    if (pMainForm->client() == NULL)
        return result;

    lscp_server_info_t* pServerInfo =
        ::lscp_get_server_info(pMainForm->client());
    if (pServerInfo && pServerInfo->protocol_version)
        ::sscanf(pServerInfo->protocol_version, "%d.%d",
            &result.major, &result.minor);

    return result;
}

} // namespace qsamplerUtilities


// end of qsamplerUtilities.cpp
1	schoenebeck	1386	// qsamplerUtilities.cpp
2			//
3			/****************************************************************************
4			Copyright (C) 2004-2007, rncbc aka Rui Nuno Capela. All rights reserved.
5	schoenebeck	1667	Copyright (C) 2007, 2008 Christian Schoenebeck
6	schoenebeck	1386
7			This program is free software; you can redistribute it and/or
8			modify it under the terms of the GNU General Public License
9			as published by the Free Software Foundation; either version 2
10			of the License, or (at your option) any later version.
11
12			This program is distributed in the hope that it will be useful,
13			but WITHOUT ANY WARRANTY; without even the implied warranty of
14			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15			GNU General Public License for more details.
16
17			You should have received a copy of the GNU General Public License along
18			with this program; if not, write to the Free Software Foundation, Inc.,
19			51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20
21			*****************************************************************************/
22
23			#include "qsamplerUtilities.h"
24
25	capela	1513	#include "qsamplerOptions.h"
26	schoenebeck	1386	#include "qsamplerMainForm.h"
27
28	capela	1499	#include <QRegExp>
29	schoenebeck	1386
30	capela	1499
31	schoenebeck	1461	using namespace QSampler;
32
33	schoenebeck	1402	namespace qsamplerUtilities {
34
35			static int _hexToNumber(char hex_digit) {
36			switch (hex_digit) {
37			case '0': return 0;
38			case '1': return 1;
39			case '2': return 2;
40			case '3': return 3;
41			case '4': return 4;
42			case '5': return 5;
43			case '6': return 6;
44			case '7': return 7;
45			case '8': return 8;
46			case '9': return 9;
47
48			case 'a': return 10;
49			case 'b': return 11;
50			case 'c': return 12;
51			case 'd': return 13;
52			case 'e': return 14;
53			case 'f': return 15;
54
55			case 'A': return 10;
56			case 'B': return 11;
57			case 'C': return 12;
58			case 'D': return 13;
59			case 'E': return 14;
60			case 'F': return 15;
61
62			default: return 0;
63			}
64			}
65
66			static int _hexsToNumber(char hex_digit0, char hex_digit1) {
67			return _hexToNumber(hex_digit1)*16 + _hexToNumber(hex_digit0);
68			}
69
70			// returns true if the connected LSCP server supports escape sequences
71			static bool _remoteSupportsEscapeSequences() {
72			const lscpVersion_t version = getRemoteLscpVersion();
73			// LSCP v1.2 or younger required
74			return (version.major > 1 \|\| (version.major == 1 && version.minor >= 2));
75			}
76
77	schoenebeck	1386	// converts the given file path into a path as expected by LSCP 1.2
78	capela	1394	QString lscpEscapePath ( const QString& sPath )
79			{
80	schoenebeck	1402	if (!_remoteSupportsEscapeSequences()) return sPath;
81	capela	1394
82	schoenebeck	1402	QString path(sPath);
83	schoenebeck	1386
84			// replace POSIX path escape sequences (%HH) by LSCP escape sequences (\xHH)
85			// TODO: missing code for other systems like Windows
86			{
87			QRegExp regexp("%[0-9a-fA-F][0-9a-fA-F]");
88	capela	1499	for (int i = path.indexOf(regexp); i >= 0; i = path.indexOf(regexp, i + 4))
89	schoenebeck	1386	path.replace(i, 1, "\\x");
90			}
91	schoenebeck	1402	// replace POSIX path escape sequence (%%) by its raw character
92	capela	1499	for (int i = path.indexOf("%%"); i >= 0; i = path.indexOf("%%", ++i))
93	schoenebeck	1402	path.remove(i, 1);
94	capela	1394
95	schoenebeck	1386	// replace all non-basic characters by LSCP escape sequences
96			{
97			const char pathSeparator = '/';
98			QRegExp regexp(QRegExp::escape("\\x") + "[0-9a-fA-F][0-9a-fA-F]");
99			for (int i = 0; i < int(path.length()); i++) {
100			// first skip all previously added LSCP escape sequences
101	capela	1499	if (path.indexOf(regexp, i) == i) {
102	schoenebeck	1386	i += 3;
103			continue;
104			}
105			// now match all non-alphanumerics
106			// (we could exclude much more characters here, but that way
107			// we're sure it just works^TM)
108	capela	1499	const char c = path.at(i).toLatin1();
109	schoenebeck	1386	if (
110			!(c >= '0' && c <= '9') &&
111			!(c >= 'a' && c <= 'z') &&
112			!(c >= 'A' && c <= 'Z') &&
113	senoner	1476	#if defined(WIN32)
114			!(c == ':') &&
115			#endif
116	schoenebeck	1386	!(c == pathSeparator)
117			) {
118			// convert the non-basic character into a LSCP escape sequence
119			char buf[5];
120	schoenebeck	1402	::snprintf(buf, sizeof(buf), "\\x%02x", static_cast<unsigned char>(c));
121	schoenebeck	1386	path.replace(i, 1, buf);
122			i += 3;
123			}
124			}
125			}
126	capela	1394
127	schoenebeck	1386	return path;
128			}
129
130	schoenebeck	1402	// converts a path returned by a LSCP command (and may contain escape
131			// sequences) into the appropriate POSIX path
132			QString lscpEscapedPathToPosix(QString path) {
133			if (!_remoteSupportsEscapeSequences()) return path;
134	capela	1394
135	schoenebeck	1402	// first escape all percent ('%') characters for POSIX
136	capela	1499	for (int i = path.indexOf('%'); i >= 0; i = path.indexOf('%', i+2))
137	schoenebeck	1402	path.replace(i, 1, "%%");
138
139			// resolve LSCP hex escape sequences (\xHH)
140			QRegExp regexp(QRegExp::escape("\\x") + "[0-9a-fA-F][0-9a-fA-F]");
141	capela	1499	for (int i = path.indexOf(regexp); i >= 0; i = path.indexOf(regexp, i + 4)) {
142			const QString sHex = path.mid(i+2, 2).toLower();
143	schoenebeck	1402	// the slash has to be escaped for POSIX as well
144			if (sHex == "2f") {
145			path.replace(i, 4, "%2f");
146			continue;
147			}
148			// all other characters we simply decode
149	capela	1499	char cAscii = _hexsToNumber(sHex.at(1).toLatin1(), sHex.at(0).toLatin1());
150	schoenebeck	1402	path.replace(i, 4, cAscii);
151			}
152
153			return path;
154			}
155
156	schoenebeck	1667	// converts the given text as expected by LSCP 1.2
157			// (that is by encoding special characters with LSCP escape sequences)
158			QString lscpEscapeText(const QString& txt) {
159			if (!_remoteSupportsEscapeSequences()) return txt;
160
161			QString text(txt);
162
163			// replace all non-basic characters by LSCP escape sequences
164			for (int i = 0; i < int(text.length()); ++i) {
165			// match all non-alphanumerics
166			// (we could exclude much more characters here, but that way
167			// we're sure it just works^TM)
168			const char c = text.at(i).toLatin1();
169			if (
170			!(c >= '0' && c <= '9') &&
171			!(c >= 'a' && c <= 'z') &&
172			!(c >= 'A' && c <= 'Z')
173			) {
174			// convert the non-basic character into a LSCP escape sequence
175			char buf[5];
176			::snprintf(buf, sizeof(buf), "\\x%02x", static_cast<unsigned char>(c));
177			text.replace(i, 1, buf);
178			i += 3;
179			}
180			}
181
182			return text;
183			}
184
185	schoenebeck	1402	// converts a text returned by a LSCP command and may contain escape
186			// sequences) into raw text, that is with all escape sequences decoded
187			QString lscpEscapedTextToRaw(QString txt) {
188			if (!_remoteSupportsEscapeSequences()) return txt;
189
190			// resolve LSCP hex escape sequences (\xHH)
191			QRegExp regexp(QRegExp::escape("\\x") + "[0-9a-fA-F][0-9a-fA-F]");
192	capela	1499	for (int i = txt.indexOf(regexp); i >= 0; i = txt.indexOf(regexp, i + 4)) {
193			const QString sHex = txt.mid(i+2, 2).toLower();
194	schoenebeck	1402	// decode into raw ASCII character
195	capela	1499	char cAscii = _hexsToNumber(sHex.at(1).toLatin1(), sHex.at(0).toLatin1());
196	schoenebeck	1402	txt.replace(i, 4, cAscii);
197			}
198
199			return txt;
200			}
201
202	capela	1394	lscpVersion_t getRemoteLscpVersion (void)
203			{
204	schoenebeck	1386	lscpVersion_t result = { 0, 0 };
205
206	schoenebeck	1461	MainForm* pMainForm = MainForm::getInstance();
207	capela	1394	if (pMainForm == NULL)
208	schoenebeck	1402	return result;
209			if (pMainForm->client() == NULL)
210			return result;
211	schoenebeck	1386
212			lscp_server_info_t* pServerInfo =
213			::lscp_get_server_info(pMainForm->client());
214	capela	1394	if (pServerInfo && pServerInfo->protocol_version)
215	schoenebeck	1402	::sscanf(pServerInfo->protocol_version, "%d.%d",
216			&result.major, &result.minor);
217	schoenebeck	1386
218			return result;
219			}
220	schoenebeck	1402
221			} // namespace qsamplerUtilities
222	capela	1464
223
224			// end of qsamplerUtilities.cpp