Merge branch 'stable-1.2'

# Conflicts:
#	.travis/linux..before_install.sh
#	.travis/linux..install.sh
#	cmake/linux/lmms.desktop
#	plugins/vst_base/CMakeLists.txt

src/CMakeLists.txt

@@ -8,7 +8,7 @@ SET(CMAKE_AUTOMOC ON)
 SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
 
 # Enable C++11
-ADD_DEFINITIONS(-std=c++0x)
+SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")
 
 IF(LMMS_BUILD_APPLE)
 	SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++")

src/core/CMakeLists.txt

@@ -1,3 +1,7 @@
+IF(LMMS_HAVE_WEAKJACK)
+	set(WEAKJACK core/audio/AudioWeakJack.c)
+ENDIF()
+	
 set(LMMS_SRCS
 	${LMMS_SRCS}
 	core/AutomatableModel.cpp
@@ -73,6 +77,7 @@ set(LMMS_SRCS
 	core/audio/AudioFileOgg.cpp
 	core/audio/AudioFileFlac.cpp
 	core/audio/AudioFileWave.cpp
+	${WEAKJACK}
 	core/audio/AudioJack.cpp
 	core/audio/AudioOss.cpp
 	core/audio/AudioSndio.cpp

src/core/ConfigManager.cpp

@@ -503,7 +503,16 @@ void ConfigManager::loadConfigFile( const QString & configFile )
 #elif defined(LMMS_BUILD_APPLE)
 		m_stkDir = qApp->applicationDirPath() + "/../share/stk/rawwaves/";
 #else
-		m_stkDir = "/usr/share/stk/rawwaves/";
+		if ( qApp->applicationDirPath().startsWith("/tmp/") )
+		{
+			// Assume AppImage bundle
+			m_stkDir = qApp->applicationDirPath() + "/../share/stk/rawwaves/";
+		}
+		else
+		{
+			// Fallback to system provided location
+			m_stkDir = "/usr/share/stk/rawwaves/";
+		}
 #endif
 	}
 #endif

src/core/InstrumentFunctions.cpp

@@ -305,7 +305,7 @@ InstrumentFunctionArpeggio::InstrumentFunctionArpeggio( Model * _parent ) :
 	m_arpCycleModel( 0.0f, 0.0f, 6.0f, 1.0f, this, tr( "Cycle steps" ) ),
 	m_arpSkipModel( 0.0f, 0.0f, 100.0f, 1.0f, this, tr( "Skip rate" ) ),
 	m_arpMissModel( 0.0f, 0.0f, 100.0f, 1.0f, this, tr( "Miss rate" ) ),
-	m_arpTimeModel( 100.0f, 25.0f, 2000.0f, 1.0f, 2000, this, tr( "Arpeggio time" ) ),
+	m_arpTimeModel( 200.0f, 25.0f, 2000.0f, 1.0f, 2000, this, tr( "Arpeggio time" ) ),
 	m_arpGateModel( 100.0f, 1.0f, 200.0f, 1.0f, this, tr( "Arpeggio gate" ) ),
 	m_arpDirectionModel( this, tr( "Arpeggio direction" ) ),
 	m_arpModeModel( this, tr( "Arpeggio mode" ) )
@@ -396,14 +396,13 @@ void InstrumentFunctionArpeggio::processNote( NotePlayHandle * _n )
 
 		frames_processed += remaining_frames_for_cur_arp;
 
-		// init with zero
-		int cur_arp_idx = 0;
-
 		// in sorted mode: is it our turn or do we have to be quiet for
 		// now?
 		if( m_arpModeModel.value() == SortMode &&
 				( ( cur_frame / arp_frames ) % total_range ) / range != (f_cnt_t) _n->index() )
 		{
+			// Set master note if not playing arp note or it will play as an ordinary note
+			_n->setMasterNote();
 			// update counters
 			frames_processed += arp_frames;
 			cur_frame += arp_frames;
@@ -416,10 +415,9 @@ void InstrumentFunctionArpeggio::processNote( NotePlayHandle * _n )
 
 			if( 100 * ( (float) rand() / (float)( RAND_MAX + 1.0f ) ) < m_arpSkipModel.value() )
 			{
-				if( cur_arp_idx == 0 )
-				{
-					_n->setMasterNote();
-				}
+				// Set master note to prevent the note to extend over skipped notes
+				// This may only be needed for lb302
+				_n->setMasterNote();
 				// update counters
 				frames_processed += arp_frames;
 				cur_frame += arp_frames;
@@ -440,6 +438,7 @@ void InstrumentFunctionArpeggio::processNote( NotePlayHandle * _n )
 			}
 		}
 
+		int cur_arp_idx = 0;
 		// process according to arpeggio-direction...
 		if( dir == ArpDirUp )
 		{
@@ -525,6 +524,13 @@ void InstrumentFunctionArpeggio::processNote( NotePlayHandle * _n )
 		frames_processed += arp_frames;
 		cur_frame += arp_frames;
 	}
+
+	// make sure note is handled as arp-base-note, even
+	// if we didn't add a sub-note so far
+	if( m_arpModeModel.value() != FreeMode )
+	{
+		_n->setMasterNote();
+	}
 }
 
 

src/core/NotePlayHandle.cpp

@@ -128,7 +128,7 @@ NotePlayHandle::NotePlayHandle( InstrumentTrack* instrumentTrack,
 }
 
 
-void NotePlayHandle::done()
+NotePlayHandle::~NotePlayHandle()
 {
 	lock();
 	noteOff( 0 );
@@ -599,7 +599,7 @@ NotePlayHandle * NotePlayHandleManager::acquire( InstrumentTrack* instrumentTrac
 
 void NotePlayHandleManager::release( NotePlayHandle * nph )
 {
-	nph->done();
+	nph->NotePlayHandle::~NotePlayHandle();
 	s_mutex.lockForRead();
 	s_available[ s_availableIndex.fetchAndAddOrdered( 1 ) + 1 ] = nph;
 	s_mutex.unlock();

src/core/PlayHandle.cpp

@@ -54,6 +54,7 @@ void PlayHandle::doProcessing()
 	if( m_usesBuffer )
 	{
 		m_bufferReleased = false;
+		BufferManager::clear(m_playHandleBuffer, Engine::mixer()->framesPerPeriod());
 		play( buffer() );
 	}
 	else

src/core/audio/AudioWeakJack.c

@@ -0,0 +1,273 @@
+/* runtime/weak dynamic JACK linking
+ *
+ * (C) 2014 Robin Gareus <robin@gareus.org>
+ *
+ * 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, 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include "AudioWeakJack.h"
+
+#ifndef USE_WEAK_JACK
+
+int have_libjack (void) {
+	return 0;
+}
+
+#else
+
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <dlfcn.h>
+#endif
+
+static void* lib_open(const char* const so) {
+#ifdef _WIN32
+	return (void*) LoadLibraryA(so);
+#else
+	return dlopen(so, RTLD_NOW|RTLD_LOCAL);
+#endif
+}
+
+static void* lib_symbol(void* const lib, const char* const sym) {
+#ifdef _WIN32
+	return (void*) GetProcAddress((HMODULE)lib, sym);
+#else
+	return dlsym(lib, sym);
+#endif
+}
+
+#if _MSC_VER && !__INTEL_COMPILER
+typedef void * pvoid_t;
+#define MAPSYM(SYM, FAIL) _j._ ## SYM = (func_t)lib_symbol(lib, "jack_" # SYM); \
+	if (!_j._ ## SYM) err |= FAIL;
+#elif defined NDEBUG
+typedef void * __attribute__ ((__may_alias__)) pvoid_t;
+#define MAPSYM(SYM, FAIL) *(pvoid_t *)(&_j._ ## SYM) = lib_symbol(lib, "jack_" # SYM); \
+	if (!_j._ ## SYM) err |= FAIL;
+#else
+typedef void * __attribute__ ((__may_alias__)) pvoid_t;
+#define MAPSYM(SYM, FAIL) *(pvoid_t *)(&_j._ ## SYM) = lib_symbol(lib, "jack_" # SYM); \
+	if (!_j._ ## SYM) { \
+		if (FAIL) { \
+			fprintf(stderr, "*** WEAK-JACK: required symbol 'jack_%s' was not found\n", "" # SYM); \
+		} \
+		err |= FAIL; \
+	}
+#endif
+
+typedef void (* func_t) (void);
+
+/* function pointers to the real jack API */
+static struct WeakJack {
+	func_t _client_open; // special case due to varargs
+
+#define JCFUN(ERR, RTYPE, NAME, RVAL)              func_t _ ## NAME ;
+#define JPFUN(ERR, RTYPE, NAME, DEF, ARGS, RVAL)   func_t _ ## NAME ;
+#define JXFUN(ERR, RTYPE, NAME, DEF, ARGS, CODE)   func_t _ ## NAME ;
+#define JVFUN(ERR, NAME, DEF, ARGS, CODE)          func_t _ ## NAME ;
+
+#include "AudioWeakJack.def"
+
+#undef JCFUN
+#undef JPFUN
+#undef JXFUN
+#undef JVFUN
+} _j;
+
+static int _status = -1;
+
+__attribute__((constructor))
+static void init_weak_jack(void)
+{
+	void* lib;
+	int err = 0;
+#ifndef NDEBUG
+	fprintf(stderr, "*** WEAK-JACK: initializing\n");
+#endif
+
+	memset(&_j, 0, sizeof(_j));
+
+#ifdef __APPLE__
+	lib = lib_open("libjack.dylib");
+	if (!lib) {
+		lib = lib_open("/usr/local/lib/libjack.dylib");
+	}
+#elif (defined _WIN32)
+# ifdef __x86_64__
+	lib = lib_open("libjack64.dll");
+# else
+	lib = lib_open("libjack.dll");
+# endif
+#else
+	lib = lib_open("libjack.so.0");
+#endif
+	if (!lib) {
+#ifndef NDEBUG
+		fprintf(stderr, "*** WEAK-JACK: libjack was not found\n");
+#endif
+		_status = -2;
+		return;
+	}
+
+	/* found library, now lookup functions */
+	MAPSYM(client_open, 2)
+
+#define JCFUN(ERR, RTYPE, NAME, RVAL)             MAPSYM(NAME, ERR)
+#define JPFUN(ERR, RTYPE, NAME, DEF, ARGS, RVAL)  MAPSYM(NAME, ERR)
+#define JXFUN(ERR, RTYPE, NAME, DEF, ARGS, CODE)  MAPSYM(NAME, ERR)
+#define JVFUN(ERR, NAME, DEF, ARGS, CODE)         MAPSYM(NAME, ERR)
+
+#include "AudioWeakJack.def"
+
+#undef JCFUN
+#undef JPFUN
+#undef JXFUN
+#undef JVFUN
+
+	/* if a required symbol is not found, disable JACK completly */
+	if (err) {
+		_j._client_open = NULL;
+	}
+	_status = err;
+#ifndef NDEBUG
+	fprintf(stderr, "*** WEAK-JACK: %s. (%d)\n", err ? "jack is not available" : "OK", _status);
+#endif
+}
+
+int have_libjack (void) {
+	if (_status == -1) {
+		init_weak_jack();
+	}
+	return _status;
+}
+
+/*******************************************************************************
+ * helper macros
+ */
+
+#if defined(__GNUC__) && (__GNUC__ > 2) && !defined(NDEBUG)
+#define likely(expr) (__builtin_expect (!!(expr), 1))
+#else
+#define likely(expr) (expr)
+#endif
+
+#ifndef NDEBUG
+# define WJACK_WARNING(NAME) \
+	fprintf(stderr, "*** WEAK-JACK: function 'jack_%s' ignored\n", "" # NAME);
+#else
+# define WJACK_WARNING(NAME) ;
+#endif
+
+/******************************************************************************
+ * JACK API wrapper functions.
+ *
+ * if a function pointer is set in the static struct WeakJack _j,
+ * the function is called directly.
+ * Otherwise a dummy NOOP implementation is provided.
+ * The latter is mainly for compile-time warnings.
+ *
+ * If libjack is not found, jack_client_open() will fail.
+ * In that case the application should not call any other libjack
+ * functions. Hence a real implementation is not needed.
+ * (jack ringbuffer may be an exception for some apps)
+ */
+
+/* dedicated support for jack_client_open(,..) variable arg function macro */
+func_t WJACK_get_client_open(void) {
+	if (_status == -1) {
+		init_weak_jack();
+	}
+	return _j._client_open;
+}
+
+/* callback to set status */
+jack_client_t * WJACK_no_client_open (const char *client_name, jack_options_t options, jack_status_t *status, ...) {
+	WJACK_WARNING(client_open);
+	if (status) { *status = JackFailure; }
+	return NULL;
+}
+
+/*******************************************************************************
+ * Macros to wrap jack API
+ */
+
+/* abstraction for jack_client functions
+ *  rtype jack_function_name (jack_client_t *client) { return rval; }
+ */
+#define JCFUN(ERR, RTYPE, NAME, RVAL) \
+	RTYPE WJACK_ ## NAME (jack_client_t *client) { \
+		if likely(_j._ ## NAME) { \
+			return ((RTYPE (*)(jack_client_t *client)) _j._ ## NAME)(client); \
+		} else { \
+			WJACK_WARNING(NAME) \
+			return RVAL; \
+		} \
+	}
+
+/* abstraction for NOOP functions with return value
+ *  rtype jack_function_name (ARGS) { return rval; }
+ */
+#define JPFUN(ERR, RTYPE, NAME, DEF, ARGS, RVAL) \
+	RTYPE WJACK_ ## NAME DEF { \
+		if likely(_j._ ## NAME) { \
+			return ((RTYPE (*)DEF) _j._ ## NAME) ARGS; \
+		} else { \
+			WJACK_WARNING(NAME) \
+			return RVAL; \
+		} \
+	}
+
+/* abstraction for functions that need custom code.
+ * e.g. functions with return-value-pointer args,
+ * use CODE to initialize value
+ *
+ *  rtype jack_function_name (ARGS) { CODE }
+ */
+#define JXFUN(ERR, RTYPE, NAME, DEF, ARGS, CODE) \
+	RTYPE WJACK_ ## NAME DEF { \
+		if likely(_j._ ## NAME) { \
+			return ((RTYPE (*)DEF) _j._ ## NAME) ARGS; \
+		} else { \
+			WJACK_WARNING(NAME) \
+			CODE \
+		} \
+	}
+
+/* abstraction for void functions with return-value-pointer args
+ *  void jack_function_name (ARGS) { CODE }
+ */
+#define JVFUN(ERR, NAME, DEF, ARGS, CODE) \
+	void WJACK_ ## NAME DEF { \
+		if likely(_j._ ## NAME) { \
+			((void (*)DEF) _j._ ## NAME) ARGS; \
+		} else { \
+			WJACK_WARNING(NAME) \
+			CODE \
+		} \
+	}
+
+#include "AudioWeakJack.def"
+
+#undef JCFUN
+#undef JPFUN
+#undef JXFUN
+#undef JVFUN
+
+#endif // end USE_WEAK_JACK

src/lmmsconfig.h.in

@@ -11,6 +11,7 @@
 #cmakedefine LMMS_HAVE_ALSA
 #cmakedefine LMMS_HAVE_FLUIDSYNTH
 #cmakedefine LMMS_HAVE_JACK
+#cmakedefine LMMS_HAVE_WEAKJACK
 #cmakedefine LMMS_HAVE_MP3LAME
 #cmakedefine LMMS_HAVE_OGGVORBIS
 #cmakedefine LMMS_HAVE_OSS