/*
 * Copyright (C) 2006-2011 David Robillard <d@drobilla.net>
 * Copyright (C) 2006-2019 Paul Davis <paul@linuxaudiosystems.com>
 * Copyright (C) 2007-2012 Carl Hetherington <carl@carlh.net>
 * Copyright (C) 2012-2019 Robin Gareus <robin@gareus.org>
 * Copyright (C) 2013-2015 Tim Mayberry <mojofunk@gmail.com>
 *
 * 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.
 */

#ifndef __ardour_audioengine_h__
#define __ardour_audioengine_h__

#ifdef WAF_BUILD
#include "libardour-config.h"
#endif

#include <atomic>
#include <iostream>
#include <list>
#include <set>
#include <cmath>
#include <exception>
#include <string>

#include <glibmm/threads.h>

#include "pbd/signals.h"
#include "pbd/pthread_utils.h"

#include "ardour/ardour.h"
#include "ardour/data_type.h"
#include "ardour/session_handle.h"
#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#include "ardour/chan_count.h"
#include "ardour/port_manager.h"

class MTDM;

namespace ARDOUR {

class InternalPort;
class MidiPort;
class MIDIDM;
class Port;
class Session;
class ProcessThread;
class AudioBackend;
struct AudioBackendInfo;

class LIBARDOUR_API AudioEngine : public PortManager, public SessionHandlePtr
{
  public:

	static AudioEngine* create ();

	virtual ~AudioEngine ();

	int discover_backends();
	std::vector<const AudioBackendInfo*> available_backends() const;
	std::string current_backend_name () const;
	std::shared_ptr<AudioBackend> set_backend (const std::string&, const std::string& arg1, const std::string& arg2);
	std::shared_ptr<AudioBackend> current_backend() const { return _backend; }
	bool setup_required () const;

	ProcessThread* main_thread() const { return _main_thread; }

	/* START BACKEND PROXY API
	 *
	 * See audio_backend.h for full documentation and semantics. These wrappers
	 * just forward to a backend implementation.
	 */

	int            start (bool for_latency_measurement=false);
	int            stop (bool for_latency_measurement=false);
	int            freewheel (bool start_stop);
	float          get_dsp_load() const ;
	void           transport_start ();
	void           transport_stop ();
	TransportState transport_state ();
	void           transport_locate (samplepos_t pos);
	samplepos_t     transport_sample();
	samplecnt_t     sample_rate () const;
	pframes_t      samples_per_cycle () const;
	int            usecs_per_cycle () const;
	size_t         raw_buffer_size (DataType t);
	samplepos_t     sample_time ();
	samplepos_t     sample_time_at_cycle_start ();
	pframes_t      samples_since_cycle_start ();
	bool           get_sync_offset (pframes_t& offset) const;

	std::string    get_last_backend_error () const { return _last_backend_error_string; }

	int            create_process_thread (boost::function<void()> func);
	int            join_process_threads ();
	bool           in_process_thread ();
	uint32_t       process_thread_count ();

	int            backend_reset_requested();
	void           request_backend_reset();
	void           request_device_list_update();
	void           launch_device_control_app();

	int            client_real_time_priority ();
	bool           is_realtime() const;

	// for the user which hold state_lock to check if reset operation is pending
	bool           is_reset_requested() const { return _hw_reset_request_count.load(); }

	int set_device_name (const std::string&);
	int set_sample_rate (float);
	int set_buffer_size (uint32_t);
	int set_interleaved (bool yn);
	int set_input_channels (uint32_t);
	int set_output_channels (uint32_t);
	int set_systemic_input_latency (uint32_t);
	int set_systemic_output_latency (uint32_t);

	/* END BACKEND PROXY API */

	bool freewheeling() const { return _freewheeling; }
	bool running() const { return _running; }

	std::string backend_id (bool for_input);

	Glib::Threads::Mutex& process_lock() { return _process_lock; }
	Glib::Threads::Mutex& latency_lock() { return _latency_lock; }

	int request_buffer_size (pframes_t samples) {
		return set_buffer_size (samples);
	}

	samplecnt_t processed_samples() const { return _processed_samples; }

	void set_session (Session *);
	void remove_session (); // not a replacement for SessionHandle::session_going_away()
	Session* session() const { return _session; }

	class NoBackendAvailable : public std::exception {
	    public:
		virtual const char *what() const throw() { return "could not connect to engine backend"; }
	};

	void split_cycle (pframes_t offset);

	int  reset_timebase ();

	void update_latencies ();

	/* this signal is sent for every process() cycle while freewheeling.
	   (the regular process() call to session->process() is not made)
	*/

	PBD::Signal1<void, pframes_t> Freewheel;

	PBD::Signal0<void> Xrun;

	/** this signal is emitted if the sample rate changes */
	PBD::Signal1<void, samplecnt_t> SampleRateChanged;

	/** this signal is emitted if the buffer size changes */
	PBD::Signal1<void, pframes_t> BufferSizeChanged;

	/** this signal is emitted if the device cannot operate properly */
	PBD::Signal0<void> DeviceError;

	/* this signal is emitted if the device list changed */

	PBD::Signal0<void> DeviceListChanged;

	/* this signal is sent if the backend ever disconnects us */

	PBD::Signal1<void,const char*> Halted;

	/* these two are emitted when the engine itself is
	   started and stopped
	*/

	PBD::Signal1<void,uint32_t> Running;
	PBD::Signal0<void> Stopped;

	/* these two are emitted when a device reset is initiated/finished
	 */

	PBD::Signal0<void> DeviceResetStarted;
	PBD::Signal0<void> DeviceResetFinished;

	static AudioEngine* instance() { return _instance; }
	static void destroy();

	void died ();

	/* The backend will cause these at the appropriate time(s) */
	int  process_callback (pframes_t nframes);
	int  buffer_size_change (pframes_t nframes);
	int  sample_rate_change (pframes_t nframes);
	void freewheel_callback (bool);
	void timebase_callback (TransportState state, pframes_t nframes, samplepos_t pos, int new_position);
	int  sync_callback (TransportState state, samplepos_t position);
	int  port_registration_callback ();
	void latency_callback (bool for_playback);
	void halted_callback (const char* reason);

	/* checks if current thread is properly set up for audio processing */
	static bool thread_initialised_for_audio_processing ();

	/* sets up the process callback thread */
	static void thread_init_callback (void *);

	/* latency measurement */

	MTDM* mtdm() { return _mtdm; }
	MIDIDM* mididm() { return _mididm; }

	int  prepare_for_latency_measurement ();
	int  start_latency_detection (bool);
	void stop_latency_detection ();
	void set_latency_input_port (const std::string&);
	void set_latency_output_port (const std::string&);
	uint32_t latency_signal_delay () const { return _latency_signal_latency; }

	enum LatencyMeasurement {
		MeasureNone,
		MeasureAudio,
		MeasureMIDI
	};

	LatencyMeasurement measuring_latency () const { return _measuring_latency; }

	/* These two are used only in builds where SILENCE_AFTER_SECONDS was
	 * set. BecameSilent will be emitted when the audioengine goes silent.
	 * reset_silence_countdown() can be used to reset the silence
	 * countdown, whose duration will be reduced to half of its previous
	 * value.
	 */

	PBD::Signal0<void> BecameSilent;
	void reset_silence_countdown ();

	void add_pending_port_deletion (Port*);
	void queue_latency_update (bool);

	enum TimingTypes {
		ProcessCallback = 0,
		/* end */
		NTT = 1
	};

	PBD::TimingStats dsp_stats[NTT];

  private:
	AudioEngine ();

	static AudioEngine*       _instance;

	Glib::Threads::Mutex       _process_lock;
	Glib::Threads::Mutex       _latency_lock;
	Glib::Threads::RecMutex    _state_lock;
	Glib::Threads::Cond        session_removed;
	bool                       session_remove_pending;
	sampleoffset_t             session_removal_countdown;
	bool                       session_deleted;
	gain_t                     session_removal_gain;
	gain_t                     session_removal_gain_step;
	bool                      _running;
	bool                      _freewheeling;
	/// number of samples between each check for changes in monitor input
	samplecnt_t                monitor_check_interval;
	/// time of the last monitor check in samples
	samplecnt_t                last_monitor_check;
	/// the number of samples processed since start() was called
	samplecnt_t               _processed_samples;
	ProcessThread*            _main_thread;
	MTDM*                     _mtdm;
	MIDIDM*                   _mididm;
	LatencyMeasurement        _measuring_latency;
	PortEngine::PortPtr       _latency_input_port;
	PortEngine::PortPtr       _latency_output_port;
	samplecnt_t               _latency_flush_samples;
	std::string               _latency_input_name;
	std::string               _latency_output_name;
	samplecnt_t               _latency_signal_latency;
	bool                      _stopped_for_latency;
	bool                      _started_for_latency;
	bool                      _in_destructor;

	std::string               _last_backend_error_string;

	PBD::Thread*              _hw_reset_event_thread;
	std::atomic<int>         _hw_reset_request_count;
	Glib::Threads::Cond       _hw_reset_condition;
	Glib::Threads::Mutex      _reset_request_lock;
	std::atomic<int>         _stop_hw_reset_processing;
	PBD::Thread*              _hw_devicelist_update_thread;
	std::atomic<int>         _hw_devicelist_update_count;
	Glib::Threads::Cond       _hw_devicelist_update_condition;
	Glib::Threads::Mutex      _devicelist_update_lock;
	std::atomic<int>         _stop_hw_devicelist_processing;
	uint32_t                  _start_cnt;
	uint32_t                  _init_countdown;
	std::atomic<int>         _pending_playback_latency_callback;
	std::atomic<int>         _pending_capture_latency_callback;

	void start_hw_event_processing();
	void stop_hw_event_processing();
	void do_reset_backend();
	void do_devicelist_update();

	typedef std::map<std::string,AudioBackendInfo*> BackendMap;
	BackendMap _backends;
	AudioBackendInfo* backend_discover (const std::string&);
	void drop_backend ();

#ifdef SILENCE_AFTER
	samplecnt_t _silence_countdown;
	uint32_t   _silence_hit_cnt;
#endif

};

} // namespace ARDOUR

#endif /* __ardour_audioengine_h__ */
