207 lines
6.0 KiB
C++
207 lines
6.0 KiB
C++
/*
|
|
* Copyright (C) 2023 Paul Davis <paul@linuxaudiosystems.com>
|
|
* Copyright (C) 2023 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 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_surround_return_h__
|
|
#define __ardour_surround_return_h__
|
|
|
|
#ifdef HAVE_LV2_1_18_6
|
|
#include <lv2/atom/atom.h>
|
|
#include <lv2/atom/forge.h>
|
|
#else
|
|
#include <lv2/lv2plug.in/ns/ext/atom/atom.h>
|
|
#include <lv2/lv2plug.in/ns/ext/atom/forge.h>
|
|
#endif
|
|
|
|
#ifdef __APPLE__
|
|
#include <CoreServices/CoreServices.h>
|
|
#include <CoreAudio/CoreAudio.h>
|
|
#include <AudioUnit/AudioUnit.h>
|
|
#endif
|
|
|
|
#include "ardour/chan_mapping.h"
|
|
#include "ardour/fixed_delay.h"
|
|
#include "ardour/lufs_meter.h"
|
|
#include "ardour/monitor_processor.h"
|
|
#include "ardour/processor.h"
|
|
|
|
namespace ARDOUR
|
|
{
|
|
class Amp;
|
|
class Session;
|
|
class SurroundSend;
|
|
class SurroundPannable;
|
|
class LV2Plugin;
|
|
|
|
class LIBARDOUR_API SurroundReturn : public Processor
|
|
{
|
|
public:
|
|
SurroundReturn (Session&, Route*);
|
|
virtual ~SurroundReturn ();
|
|
|
|
bool can_support_io_configuration (const ChanCount& in, ChanCount& out);
|
|
void run (BufferSet& bufs, samplepos_t start_sample, samplepos_t end_sample, double speed, pframes_t nframes, bool);
|
|
int set_block_size (pframes_t);
|
|
void flush ();
|
|
void set_playback_offset (samplecnt_t cnt);
|
|
bool display_to_user () const { return false; }
|
|
|
|
void setup_export (std::string const&, samplepos_t, samplepos_t);
|
|
void finalize_export ();
|
|
|
|
size_t n_channels () const {
|
|
return _current_n_channels;
|
|
}
|
|
|
|
size_t total_n_channels (bool with_beds = true) const {
|
|
return _total_n_channels - (with_beds ? 0 : 10);
|
|
}
|
|
|
|
std::shared_ptr<LV2Plugin> surround_processor () const {
|
|
return _surround_processor;
|
|
}
|
|
|
|
bool have_au_renderer () const {
|
|
return _have_au_renderer;
|
|
}
|
|
|
|
bool load_au_preset (size_t);
|
|
bool set_au_param (size_t, float);
|
|
|
|
std::shared_ptr<PBD::Controllable> binaural_render_controllable () const {
|
|
return _binaural_render_control;
|
|
}
|
|
|
|
enum MainOutputFormat {
|
|
OUTPUT_FORMAT_5_1 = 2,
|
|
OUTPUT_FORMAT_7_1_4 = 6
|
|
};
|
|
|
|
MainOutputFormat output_format () const {
|
|
return _current_output_format;
|
|
}
|
|
|
|
std::shared_ptr<PBD::Controllable> output_format_controllable () const {
|
|
return _output_format_control;
|
|
}
|
|
|
|
/* a value <= -200 indicates that no data is available */
|
|
float integrated_loudness () const;
|
|
float max_momentary () const;
|
|
float momentary () const;
|
|
float max_dbtp () const;
|
|
|
|
samplecnt_t signal_latency () const;
|
|
|
|
/* XXX this is only for testing */
|
|
void set_bed_mix (bool on, std::string const& ref, int* cmap = NULL);
|
|
void set_sync_and_align (bool on);
|
|
void set_ffoa (float);
|
|
void set_with_all_metadata (bool);
|
|
|
|
int set_state (XMLNode const&, int version);
|
|
|
|
protected:
|
|
XMLNode& state () const;
|
|
|
|
private:
|
|
static const size_t max_object_id = 128; // happens to be the same as a constant in a well known surround system
|
|
static const size_t num_pan_parameters = 8; // X, Y, Z, Size, Snap [ElevEn, Ramp, Zones]
|
|
|
|
void forge_int_msg (uint32_t obj_id, uint32_t key, int val, uint32_t key2 = 0, int val2 = 0);
|
|
void maybe_send_metadata (size_t id, pframes_t frame, pan_t const v[num_pan_parameters], bool force = false);
|
|
void evaluate (size_t id, std::shared_ptr<SurroundPannable> const&, timepos_t const& , pframes_t, bool force = false);
|
|
|
|
void reset_object_map ();
|
|
void latency_changed ();
|
|
|
|
std::shared_ptr<LV2Plugin> _surround_processor;
|
|
|
|
LUFSMeter _lufs_meter;
|
|
|
|
std::shared_ptr<Amp> _trim;
|
|
|
|
class OutputFormatControl : public MPControl<bool>
|
|
{
|
|
public:
|
|
OutputFormatControl (bool v, std::string const& n, PBD::Controllable::Flag f);
|
|
virtual std::string get_user_string () const;
|
|
};
|
|
|
|
std::shared_ptr<OutputFormatControl> _output_format_control;
|
|
|
|
class BinauralRenderControl : public MPControl<bool>
|
|
{
|
|
public:
|
|
BinauralRenderControl (bool v, std::string const& n, PBD::Controllable::Flag f);
|
|
virtual std::string get_user_string () const;
|
|
};
|
|
|
|
std::shared_ptr<BinauralRenderControl> _binaural_render_control;
|
|
|
|
#ifdef __APPLE__
|
|
::AudioUnit _au;
|
|
AudioBufferList* _au_buffers;
|
|
samplecnt_t _au_samples_processed;
|
|
float* _au_data[12];
|
|
|
|
struct LIBARDOUR_API AUParameter {
|
|
AudioUnitParameterID id;
|
|
AudioUnitScope scope;
|
|
AudioUnitElement element;
|
|
std::string label;
|
|
float lower, upper, normal;
|
|
};
|
|
|
|
std::vector<AUParameter> _au_params;
|
|
std::vector<AUPreset> _au_presets;
|
|
|
|
static OSStatus _render_callback(void*, AudioUnitRenderActionFlags*, const AudioTimeStamp*, UInt32, UInt32, AudioBufferList*);
|
|
OSStatus render_callback(AudioUnitRenderActionFlags*, const AudioTimeStamp*, UInt32, UInt32, AudioBufferList*);
|
|
#endif
|
|
|
|
bool _have_au_renderer;
|
|
LV2_Atom_Forge _forge;
|
|
uint8_t _atom_buf[8192];
|
|
pan_t _current_value[max_object_id][num_pan_parameters];
|
|
int _current_render_mode[max_object_id];
|
|
size_t _channel_id_map[max_object_id];
|
|
size_t _current_n_channels;
|
|
size_t _total_n_channels;
|
|
MainOutputFormat _current_output_format;
|
|
BufferSet _surround_bufs;
|
|
ChanMapping _in_map;
|
|
ChanMapping _out_map;
|
|
bool _exporting;
|
|
samplepos_t _export_start;
|
|
samplepos_t _export_end;
|
|
bool _rolling;
|
|
bool _with_bed;
|
|
bool _sync_and_align;
|
|
bool _with_all_metadata;
|
|
bool _content_creation;
|
|
float _ffoa;
|
|
std::string _export_reference;
|
|
FixedDelay _delaybuffers;
|
|
std::atomic<int> _flush;
|
|
};
|
|
|
|
} // namespace ARDOUR
|
|
|
|
#endif /* __ardour_surround_return_h__ */
|